Monero
Loading...
Searching...
No Matches
core_rpc_server_commands_defs.h
Go to the documentation of this file.
1// Copyright (c) 2014-2022, The Monero Project
2//
3// All rights reserved.
4//
5// Redistribution and use in source and binary forms, with or without modification, are
6// permitted provided that the following conditions are met:
7//
8// 1. Redistributions of source code must retain the above copyright notice, this list of
9// conditions and the following disclaimer.
10//
11// 2. Redistributions in binary form must reproduce the above copyright notice, this list
12// of conditions and the following disclaimer in the documentation and/or other
13// materials provided with the distribution.
14//
15// 3. Neither the name of the copyright holder nor the names of its contributors may be
16// used to endorse or promote products derived from this software without specific
17// prior written permission.
18//
19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
20// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
22// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
26// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
27// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28//
29// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
30
31#pragma once
32
33#include "string_tools.h"
34
35#include "cryptonote_protocol/cryptonote_protocol_defs.h"
36#include "cryptonote_basic/cryptonote_basic.h"
37#include "cryptonote_basic/difficulty.h"
38#include "crypto/hash.h"
39#include "rpc/rpc_handler.h"
40#include "common/varint.h"
41#include "common/perf_timer.h"
42
43namespace
44{
45 template<typename T>
46 std::string compress_integer_array(const std::vector<T> &v)
47 {
48 std::string s;
49 s.resize(v.size() * (sizeof(T) * 8 / 7 + 1));
50 char *ptr = (char*)s.data();
51 for (const T &t: v)
52 tools::write_varint(ptr, t);
53 s.resize(ptr - s.data());
54 return s;
55 }
56
57 template<typename T>
58 std::vector<T> decompress_integer_array(const std::string &s)
59 {
60 std::vector<T> v;
61 v.reserve(s.size());
62 int read = 0;
63 const std::string::const_iterator end = s.end();
64 for (std::string::const_iterator i = s.begin(); i != end; std::advance(i, read))
65 {
66 T t;
67 read = tools::read_varint(std::string::const_iterator(i), s.end(), t);
68 CHECK_AND_ASSERT_THROW_MES(read > 0 && read <= 256, "Error decompressing data");
69 v.push_back(t);
70 }
71 return v;
72 }
73}
74
75namespace cryptonote
76{
77 //-----------------------------------------------
78#define CORE_RPC_STATUS_OK "OK"
79#define CORE_RPC_STATUS_BUSY "BUSY"
80#define CORE_RPC_STATUS_NOT_MINING "NOT MINING"
81#define CORE_RPC_STATUS_PAYMENT_REQUIRED "PAYMENT REQUIRED"
82
83// When making *any* change here, bump minor
84// If the change is incompatible, then bump major and set minor to 0
85// This ensures CORE_RPC_VERSION always increases, that every change
86// has its own version, and that clients can just test major to see
87// whether they can talk to a given daemon without having to know in
88// advance which version they will stop working with
89// Don't go over 32767 for any of these
90#define CORE_RPC_VERSION_MAJOR 3
91#define CORE_RPC_VERSION_MINOR 11
92#define MAKE_CORE_RPC_VERSION(major,minor) (((major)<<16)|(minor))
93#define CORE_RPC_VERSION MAKE_CORE_RPC_VERSION(CORE_RPC_VERSION_MAJOR, CORE_RPC_VERSION_MINOR)
94
95 struct rpc_request_base
96 {
97 BEGIN_KV_SERIALIZE_MAP()
98 END_KV_SERIALIZE_MAP()
99 };
100
101 struct rpc_response_base
102 {
103 std::string status;
104 bool untrusted;
105
106 rpc_response_base(): untrusted(false) {}
107
108 BEGIN_KV_SERIALIZE_MAP()
109 KV_SERIALIZE(status)
110 KV_SERIALIZE(untrusted)
111 END_KV_SERIALIZE_MAP()
112 };
113
114 struct rpc_access_request_base: public rpc_request_base
115 {
116 std::string client;
117
118 BEGIN_KV_SERIALIZE_MAP()
119 KV_SERIALIZE_PARENT(rpc_request_base)
120 KV_SERIALIZE(client)
121 END_KV_SERIALIZE_MAP()
122 };
123
124 struct rpc_access_response_base: public rpc_response_base
125 {
126 uint64_t credits;
127 std::string top_hash;
128
129 rpc_access_response_base(): credits(0) {}
130
131 BEGIN_KV_SERIALIZE_MAP()
132 KV_SERIALIZE_PARENT(rpc_response_base)
133 KV_SERIALIZE(credits)
134 KV_SERIALIZE(top_hash)
135 END_KV_SERIALIZE_MAP()
136 };
137
138 struct COMMAND_RPC_GET_HEIGHT
139 {
140 struct request_t: public rpc_request_base
141 {
142 BEGIN_KV_SERIALIZE_MAP()
143 KV_SERIALIZE_PARENT(rpc_request_base)
144 END_KV_SERIALIZE_MAP()
145 };
146 typedef epee::misc_utils::struct_init<request_t> request;
147
148 struct response_t: public rpc_response_base
149 {
150 uint64_t height;
151 std::string hash;
152
153 BEGIN_KV_SERIALIZE_MAP()
154 KV_SERIALIZE_PARENT(rpc_response_base)
155 KV_SERIALIZE(height)
156 KV_SERIALIZE(hash)
157 END_KV_SERIALIZE_MAP()
158 };
159 typedef epee::misc_utils::struct_init<response_t> response;
160 };
161
162 struct COMMAND_RPC_GET_BLOCKS_FAST
163 {
164
165 struct request_t: public rpc_access_request_base
166 {
167 std::list<crypto::hash> block_ids; //*first 10 blocks id goes sequential, next goes in pow(2,n) offset, like 2, 4, 8, 16, 32, 64 and so on, and the last one is always genesis block */
168 uint64_t start_height;
169 bool prune;
170 bool no_miner_tx;
171 BEGIN_KV_SERIALIZE_MAP()
172 KV_SERIALIZE_PARENT(rpc_access_request_base)
173 KV_SERIALIZE_CONTAINER_POD_AS_BLOB(block_ids)
174 KV_SERIALIZE(start_height)
175 KV_SERIALIZE(prune)
176 KV_SERIALIZE_OPT(no_miner_tx, false)
177 END_KV_SERIALIZE_MAP()
178 };
179 typedef epee::misc_utils::struct_init<request_t> request;
180
181 struct tx_output_indices
182 {
183 std::vector<uint64_t> indices;
184
185 BEGIN_KV_SERIALIZE_MAP()
186 KV_SERIALIZE(indices)
187 END_KV_SERIALIZE_MAP()
188 };
189
190 struct block_output_indices
191 {
192 std::vector<tx_output_indices> indices;
193
194 BEGIN_KV_SERIALIZE_MAP()
195 KV_SERIALIZE(indices)
196 END_KV_SERIALIZE_MAP()
197 };
198
199 struct response_t: public rpc_access_response_base
200 {
201 std::vector<block_complete_entry> blocks;
202 uint64_t start_height;
203 uint64_t current_height;
204 std::vector<block_output_indices> output_indices;
205
206 BEGIN_KV_SERIALIZE_MAP()
207 KV_SERIALIZE_PARENT(rpc_access_response_base)
208 KV_SERIALIZE(blocks)
209 KV_SERIALIZE(start_height)
210 KV_SERIALIZE(current_height)
211 KV_SERIALIZE(output_indices)
212 END_KV_SERIALIZE_MAP()
213 };
214 typedef epee::misc_utils::struct_init<response_t> response;
215 };
216
217 struct COMMAND_RPC_GET_BLOCKS_BY_HEIGHT
218 {
219 struct request_t: public rpc_access_request_base
220 {
221 std::vector<uint64_t> heights;
222 BEGIN_KV_SERIALIZE_MAP()
223 KV_SERIALIZE_PARENT(rpc_access_request_base)
224 KV_SERIALIZE(heights)
225 END_KV_SERIALIZE_MAP()
226 };
227 typedef epee::misc_utils::struct_init<request_t> request;
228
229 struct response_t: public rpc_access_response_base
230 {
231 std::vector<block_complete_entry> blocks;
232
233 BEGIN_KV_SERIALIZE_MAP()
234 KV_SERIALIZE_PARENT(rpc_access_response_base)
235 KV_SERIALIZE(blocks)
236 END_KV_SERIALIZE_MAP()
237 };
238 typedef epee::misc_utils::struct_init<response_t> response;
239 };
240
241 struct COMMAND_RPC_GET_ALT_BLOCKS_HASHES
242 {
243 struct request_t: public rpc_access_request_base
244 {
245 BEGIN_KV_SERIALIZE_MAP()
246 KV_SERIALIZE_PARENT(rpc_access_request_base)
247 END_KV_SERIALIZE_MAP()
248 };
249 typedef epee::misc_utils::struct_init<request_t> request;
250
251 struct response_t: public rpc_access_response_base
252 {
253 std::vector<std::string> blks_hashes;
254
255 BEGIN_KV_SERIALIZE_MAP()
256 KV_SERIALIZE_PARENT(rpc_access_response_base)
257 KV_SERIALIZE(blks_hashes)
258 END_KV_SERIALIZE_MAP()
259 };
260 typedef epee::misc_utils::struct_init<response_t> response;
261 };
262 struct COMMAND_RPC_GET_HASHES_FAST
263 {
264
265 struct request_t: public rpc_access_request_base
266 {
267 std::list<crypto::hash> block_ids; //*first 10 blocks id goes sequential, next goes in pow(2,n) offset, like 2, 4, 8, 16, 32, 64 and so on, and the last one is always genesis block */
268 uint64_t start_height;
269 BEGIN_KV_SERIALIZE_MAP()
270 KV_SERIALIZE_PARENT(rpc_access_request_base)
271 KV_SERIALIZE_CONTAINER_POD_AS_BLOB(block_ids)
272 KV_SERIALIZE(start_height)
273 END_KV_SERIALIZE_MAP()
274 };
275 typedef epee::misc_utils::struct_init<request_t> request;
276
277 struct response_t: public rpc_access_response_base
278 {
279 std::vector<crypto::hash> m_block_ids;
280 uint64_t start_height;
281 uint64_t current_height;
282
283 BEGIN_KV_SERIALIZE_MAP()
284 KV_SERIALIZE_PARENT(rpc_access_response_base)
285 KV_SERIALIZE_CONTAINER_POD_AS_BLOB(m_block_ids)
286 KV_SERIALIZE(start_height)
287 KV_SERIALIZE(current_height)
288 END_KV_SERIALIZE_MAP()
289 };
290 typedef epee::misc_utils::struct_init<response_t> response;
291 };
292 //-----------------------------------------------
293 struct COMMAND_RPC_SUBMIT_RAW_TX
294 {
295 struct request_t
296 {
297 std::string address;
298 std::string view_key;
299 std::string tx;
300
301 BEGIN_KV_SERIALIZE_MAP()
302 KV_SERIALIZE(address)
303 KV_SERIALIZE(view_key)
304 KV_SERIALIZE(tx)
305 END_KV_SERIALIZE_MAP()
306 };
307 typedef epee::misc_utils::struct_init<request_t> request;
308
309
310 struct response_t
311 {
312 std::string status;
313 std::string error;
314
315 BEGIN_KV_SERIALIZE_MAP()
316 KV_SERIALIZE(status)
317 KV_SERIALIZE(error)
318 END_KV_SERIALIZE_MAP()
319 };
320 typedef epee::misc_utils::struct_init<response_t> response;
321 };
322 //-----------------------------------------------
323 struct COMMAND_RPC_GET_TRANSACTIONS
324 {
325 struct request_t: public rpc_access_request_base
326 {
327 std::vector<std::string> txs_hashes;
328 bool decode_as_json;
329 bool prune;
330 bool split;
331
332 BEGIN_KV_SERIALIZE_MAP()
333 KV_SERIALIZE_PARENT(rpc_access_request_base)
334 KV_SERIALIZE(txs_hashes)
335 KV_SERIALIZE(decode_as_json)
336 KV_SERIALIZE_OPT(prune, false)
337 KV_SERIALIZE_OPT(split, false)
338 END_KV_SERIALIZE_MAP()
339 };
340 typedef epee::misc_utils::struct_init<request_t> request;
341
342 struct entry
343 {
344 std::string tx_hash;
345 std::string as_hex;
346 std::string pruned_as_hex;
347 std::string prunable_as_hex;
348 std::string prunable_hash;
349 std::string as_json;
350 bool in_pool;
351 bool double_spend_seen;
352 uint64_t block_height;
353 uint64_t confirmations;
354 uint64_t block_timestamp;
355 uint64_t received_timestamp;
356 std::vector<uint64_t> output_indices;
357 bool relayed;
358
359 BEGIN_KV_SERIALIZE_MAP()
360 KV_SERIALIZE(tx_hash)
361 KV_SERIALIZE(as_hex)
362 KV_SERIALIZE(pruned_as_hex)
363 KV_SERIALIZE(prunable_as_hex)
364 KV_SERIALIZE(prunable_hash)
365 KV_SERIALIZE(as_json)
366 KV_SERIALIZE(in_pool)
367 KV_SERIALIZE(double_spend_seen)
368 if (!this_ref.in_pool)
369 {
370 KV_SERIALIZE(block_height)
371 KV_SERIALIZE(confirmations)
372 KV_SERIALIZE(block_timestamp)
373 KV_SERIALIZE(output_indices)
374 }
375 else
376 {
377 KV_SERIALIZE(relayed)
378 KV_SERIALIZE(received_timestamp)
379 }
380 END_KV_SERIALIZE_MAP()
381 };
382
383 struct response_t: public rpc_access_response_base
384 {
385 // older compatibility stuff
386 std::vector<std::string> txs_as_hex; //transactions blobs as hex (old compat)
387 std::vector<std::string> txs_as_json; //transactions decoded as json (old compat)
388
389 // in both old and new
390 std::vector<std::string> missed_tx; //not found transactions
391
392 // new style
393 std::vector<entry> txs;
394
395 BEGIN_KV_SERIALIZE_MAP()
396 KV_SERIALIZE_PARENT(rpc_access_response_base)
397 KV_SERIALIZE(txs_as_hex)
398 KV_SERIALIZE(txs_as_json)
399 KV_SERIALIZE(txs)
400 KV_SERIALIZE(missed_tx)
401 END_KV_SERIALIZE_MAP()
402 };
403 typedef epee::misc_utils::struct_init<response_t> response;
404 };
405
406 //-----------------------------------------------
407 struct COMMAND_RPC_IS_KEY_IMAGE_SPENT
408 {
409 enum STATUS {
410 UNSPENT = 0,
411 SPENT_IN_BLOCKCHAIN = 1,
412 SPENT_IN_POOL = 2,
413 };
414
415 struct request_t: public rpc_access_request_base
416 {
417 std::vector<std::string> key_images;
418
419 BEGIN_KV_SERIALIZE_MAP()
420 KV_SERIALIZE_PARENT(rpc_access_request_base)
421 KV_SERIALIZE(key_images)
422 END_KV_SERIALIZE_MAP()
423 };
424 typedef epee::misc_utils::struct_init<request_t> request;
425
426
427 struct response_t: public rpc_access_response_base
428 {
429 std::vector<int> spent_status;
430
431 BEGIN_KV_SERIALIZE_MAP()
432 KV_SERIALIZE_PARENT(rpc_access_response_base)
433 KV_SERIALIZE(spent_status)
434 END_KV_SERIALIZE_MAP()
435 };
436 typedef epee::misc_utils::struct_init<response_t> response;
437 };
438
439 //-----------------------------------------------
440 struct COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES
441 {
442 struct request_t: public rpc_access_request_base
443 {
444 crypto::hash txid;
445 BEGIN_KV_SERIALIZE_MAP()
446 KV_SERIALIZE_PARENT(rpc_access_request_base)
447 KV_SERIALIZE_VAL_POD_AS_BLOB(txid)
448 END_KV_SERIALIZE_MAP()
449 };
450 typedef epee::misc_utils::struct_init<request_t> request;
451
452
453 struct response_t: public rpc_access_response_base
454 {
455 std::vector<uint64_t> o_indexes;
456
457 BEGIN_KV_SERIALIZE_MAP()
458 KV_SERIALIZE_PARENT(rpc_access_response_base)
459 KV_SERIALIZE(o_indexes)
460 END_KV_SERIALIZE_MAP()
461 };
462 typedef epee::misc_utils::struct_init<response_t> response;
463 };
464 //-----------------------------------------------
465 struct get_outputs_out
466 {
467 uint64_t amount;
468 uint64_t index;
469
470 BEGIN_KV_SERIALIZE_MAP()
471 KV_SERIALIZE(amount)
472 KV_SERIALIZE(index)
473 END_KV_SERIALIZE_MAP()
474 };
475
476 struct COMMAND_RPC_GET_OUTPUTS_BIN
477 {
478 struct request_t: public rpc_access_request_base
479 {
480 std::vector<get_outputs_out> outputs;
481 bool get_txid;
482
483 BEGIN_KV_SERIALIZE_MAP()
484 KV_SERIALIZE_PARENT(rpc_access_request_base)
485 KV_SERIALIZE(outputs)
486 KV_SERIALIZE_OPT(get_txid, true)
487 END_KV_SERIALIZE_MAP()
488 };
489 typedef epee::misc_utils::struct_init<request_t> request;
490
491 struct outkey
492 {
493 crypto::public_key key;
494 rct::key mask;
495 bool unlocked;
496 uint64_t height;
497 crypto::hash txid;
498
499 BEGIN_KV_SERIALIZE_MAP()
500 KV_SERIALIZE_VAL_POD_AS_BLOB(key)
501 KV_SERIALIZE_VAL_POD_AS_BLOB(mask)
502 KV_SERIALIZE(unlocked)
503 KV_SERIALIZE(height)
504 KV_SERIALIZE_VAL_POD_AS_BLOB(txid)
505 END_KV_SERIALIZE_MAP()
506 };
507
508 struct response_t: public rpc_access_response_base
509 {
510 std::vector<outkey> outs;
511
512 BEGIN_KV_SERIALIZE_MAP()
513 KV_SERIALIZE_PARENT(rpc_access_response_base)
514 KV_SERIALIZE(outs)
515 END_KV_SERIALIZE_MAP()
516 };
517 typedef epee::misc_utils::struct_init<response_t> response;
518 };
519 //-----------------------------------------------
520 struct COMMAND_RPC_GET_OUTPUTS
521 {
522 struct request_t: public rpc_access_request_base
523 {
524 std::vector<get_outputs_out> outputs;
525 bool get_txid;
526
527 BEGIN_KV_SERIALIZE_MAP()
528 KV_SERIALIZE_PARENT(rpc_access_request_base)
529 KV_SERIALIZE(outputs)
530 KV_SERIALIZE(get_txid)
531 END_KV_SERIALIZE_MAP()
532 };
533 typedef epee::misc_utils::struct_init<request_t> request;
534
535 struct outkey
536 {
537 std::string key;
538 std::string mask;
539 bool unlocked;
540 uint64_t height;
541 std::string txid;
542
543 BEGIN_KV_SERIALIZE_MAP()
544 KV_SERIALIZE(key)
545 KV_SERIALIZE(mask)
546 KV_SERIALIZE(unlocked)
547 KV_SERIALIZE(height)
548 KV_SERIALIZE(txid)
549 END_KV_SERIALIZE_MAP()
550 };
551
552 struct response_t: public rpc_access_response_base
553 {
554 std::vector<outkey> outs;
555
556 BEGIN_KV_SERIALIZE_MAP()
557 KV_SERIALIZE_PARENT(rpc_access_response_base)
558 KV_SERIALIZE(outs)
559 END_KV_SERIALIZE_MAP()
560 };
561 typedef epee::misc_utils::struct_init<response_t> response;
562 };
563 //-----------------------------------------------
564 struct COMMAND_RPC_SEND_RAW_TX
565 {
566 struct request_t: public rpc_access_request_base
567 {
568 std::string tx_as_hex;
569 bool do_not_relay;
570 bool do_sanity_checks;
571
572 BEGIN_KV_SERIALIZE_MAP()
573 KV_SERIALIZE_PARENT(rpc_access_request_base);
574 KV_SERIALIZE(tx_as_hex)
575 KV_SERIALIZE_OPT(do_not_relay, false)
576 KV_SERIALIZE_OPT(do_sanity_checks, true)
577 END_KV_SERIALIZE_MAP()
578 };
579 typedef epee::misc_utils::struct_init<request_t> request;
580
581
582 struct response_t: public rpc_access_response_base
583 {
584 std::string reason;
585 bool not_relayed;
586 bool low_mixin;
587 bool double_spend;
588 bool invalid_input;
589 bool invalid_output;
590 bool too_big;
591 bool overspend;
592 bool fee_too_low;
593 bool too_few_outputs;
594 bool sanity_check_failed;
595
596 BEGIN_KV_SERIALIZE_MAP()
597 KV_SERIALIZE_PARENT(rpc_access_response_base)
598 KV_SERIALIZE(reason)
599 KV_SERIALIZE(not_relayed)
600 KV_SERIALIZE(low_mixin)
601 KV_SERIALIZE(double_spend)
602 KV_SERIALIZE(invalid_input)
603 KV_SERIALIZE(invalid_output)
604 KV_SERIALIZE(too_big)
605 KV_SERIALIZE(overspend)
606 KV_SERIALIZE(fee_too_low)
607 KV_SERIALIZE(too_few_outputs)
608 KV_SERIALIZE(sanity_check_failed)
609 END_KV_SERIALIZE_MAP()
610 };
611 typedef epee::misc_utils::struct_init<response_t> response;
612 };
613 //-----------------------------------------------
614 struct COMMAND_RPC_START_MINING
615 {
616 struct request_t: public rpc_request_base
617 {
618 std::string miner_address;
619 uint64_t threads_count;
620 bool do_background_mining;
621 bool ignore_battery;
622
623 BEGIN_KV_SERIALIZE_MAP()
624 KV_SERIALIZE_PARENT(rpc_request_base)
625 KV_SERIALIZE(miner_address)
626 KV_SERIALIZE(threads_count)
627 KV_SERIALIZE(do_background_mining)
628 KV_SERIALIZE(ignore_battery)
629 END_KV_SERIALIZE_MAP()
630 };
631 typedef epee::misc_utils::struct_init<request_t> request;
632
633 struct response_t: public rpc_response_base
634 {
635 BEGIN_KV_SERIALIZE_MAP()
636 KV_SERIALIZE_PARENT(rpc_response_base)
637 END_KV_SERIALIZE_MAP()
638 };
639 typedef epee::misc_utils::struct_init<response_t> response;
640 };
641 //-----------------------------------------------
642 struct COMMAND_RPC_GET_INFO
643 {
644 struct request_t: public rpc_access_request_base
645 {
646 BEGIN_KV_SERIALIZE_MAP()
647 KV_SERIALIZE_PARENT(rpc_access_request_base);
648 END_KV_SERIALIZE_MAP()
649 };
650 typedef epee::misc_utils::struct_init<request_t> request;
651
652 struct response_t: public rpc_access_response_base
653 {
654 uint64_t height;
655 uint64_t target_height;
656 uint64_t difficulty;
657 std::string wide_difficulty;
658 uint64_t difficulty_top64;
659 uint64_t target;
660 uint64_t tx_count;
661 uint64_t tx_pool_size;
662 uint64_t alt_blocks_count;
663 uint64_t outgoing_connections_count;
664 uint64_t incoming_connections_count;
665 uint64_t rpc_connections_count;
666 uint64_t white_peerlist_size;
667 uint64_t grey_peerlist_size;
668 bool mainnet;
669 bool testnet;
670 bool stagenet;
671 std::string nettype;
672 std::string top_block_hash;
673 uint64_t cumulative_difficulty;
674 std::string wide_cumulative_difficulty;
675 uint64_t cumulative_difficulty_top64;
676 uint64_t block_size_limit;
677 uint64_t block_weight_limit;
678 uint64_t block_size_median;
679 uint64_t block_weight_median;
680 uint64_t adjusted_time;
681 uint64_t start_time;
682 uint64_t free_space;
683 bool offline;
684 std::string bootstrap_daemon_address;
685 uint64_t height_without_bootstrap;
686 bool was_bootstrap_ever_used;
687 uint64_t database_size;
688 bool update_available;
689 bool busy_syncing;
690 std::string version;
691 bool synchronized;
692 bool restricted;
693
694 BEGIN_KV_SERIALIZE_MAP()
695 KV_SERIALIZE_PARENT(rpc_access_response_base)
696 KV_SERIALIZE(height)
697 KV_SERIALIZE(target_height)
698 KV_SERIALIZE(difficulty)
699 KV_SERIALIZE(wide_difficulty)
700 KV_SERIALIZE(difficulty_top64)
701 KV_SERIALIZE(target)
702 KV_SERIALIZE(tx_count)
703 KV_SERIALIZE(tx_pool_size)
704 KV_SERIALIZE(alt_blocks_count)
705 KV_SERIALIZE(outgoing_connections_count)
706 KV_SERIALIZE(incoming_connections_count)
707 KV_SERIALIZE(rpc_connections_count)
708 KV_SERIALIZE(white_peerlist_size)
709 KV_SERIALIZE(grey_peerlist_size)
710 KV_SERIALIZE(mainnet)
711 KV_SERIALIZE(testnet)
712 KV_SERIALIZE(stagenet)
713 KV_SERIALIZE(nettype)
714 KV_SERIALIZE(top_block_hash)
715 KV_SERIALIZE(cumulative_difficulty)
716 KV_SERIALIZE(wide_cumulative_difficulty)
717 KV_SERIALIZE(cumulative_difficulty_top64)
718 KV_SERIALIZE(block_size_limit)
719 KV_SERIALIZE_OPT(block_weight_limit, (uint64_t)0)
720 KV_SERIALIZE(block_size_median)
721 KV_SERIALIZE_OPT(block_weight_median, (uint64_t)0)
722 KV_SERIALIZE(adjusted_time)
723 KV_SERIALIZE(start_time)
724 KV_SERIALIZE(free_space)
725 KV_SERIALIZE(offline)
726 KV_SERIALIZE(bootstrap_daemon_address)
727 KV_SERIALIZE(height_without_bootstrap)
728 KV_SERIALIZE(was_bootstrap_ever_used)
729 KV_SERIALIZE(database_size)
730 KV_SERIALIZE(update_available)
731 KV_SERIALIZE(busy_syncing)
732 KV_SERIALIZE(version)
733 KV_SERIALIZE(synchronized)
734 KV_SERIALIZE(restricted)
735 END_KV_SERIALIZE_MAP()
736 };
737 typedef epee::misc_utils::struct_init<response_t> response;
738 };
739
740
741 //-----------------------------------------------
742 struct COMMAND_RPC_GET_NET_STATS
743 {
744 struct request_t: public rpc_request_base
745 {
746 BEGIN_KV_SERIALIZE_MAP()
747 KV_SERIALIZE_PARENT(rpc_request_base)
748 END_KV_SERIALIZE_MAP()
749 };
750 typedef epee::misc_utils::struct_init<request_t> request;
751
752
753 struct response_t: public rpc_response_base
754 {
755 uint64_t start_time;
756 uint64_t total_packets_in;
757 uint64_t total_bytes_in;
758 uint64_t total_packets_out;
759 uint64_t total_bytes_out;
760
761 BEGIN_KV_SERIALIZE_MAP()
762 KV_SERIALIZE_PARENT(rpc_response_base)
763 KV_SERIALIZE(start_time)
764 KV_SERIALIZE(total_packets_in)
765 KV_SERIALIZE(total_bytes_in)
766 KV_SERIALIZE(total_packets_out)
767 KV_SERIALIZE(total_bytes_out)
768 END_KV_SERIALIZE_MAP()
769 };
770 typedef epee::misc_utils::struct_init<response_t> response;
771 };
772
773 //-----------------------------------------------
774 struct COMMAND_RPC_STOP_MINING
775 {
776 struct request_t: public rpc_request_base
777 {
778 BEGIN_KV_SERIALIZE_MAP()
779 KV_SERIALIZE_PARENT(rpc_request_base)
780 END_KV_SERIALIZE_MAP()
781 };
782 typedef epee::misc_utils::struct_init<request_t> request;
783
784
785 struct response_t: public rpc_response_base
786 {
787 BEGIN_KV_SERIALIZE_MAP()
788 KV_SERIALIZE_PARENT(rpc_response_base)
789 END_KV_SERIALIZE_MAP()
790 };
791 typedef epee::misc_utils::struct_init<response_t> response;
792 };
793
794 //-----------------------------------------------
795 struct COMMAND_RPC_MINING_STATUS
796 {
797 struct request_t: public rpc_request_base
798 {
799 BEGIN_KV_SERIALIZE_MAP()
800 KV_SERIALIZE_PARENT(rpc_request_base)
801 END_KV_SERIALIZE_MAP()
802 };
803 typedef epee::misc_utils::struct_init<request_t> request;
804
805
806 struct response_t: public rpc_response_base
807 {
808 bool active;
809 uint64_t speed;
810 uint32_t threads_count;
811 std::string address;
812 std::string pow_algorithm;
813 bool is_background_mining_enabled;
814 uint8_t bg_idle_threshold;
815 uint8_t bg_min_idle_seconds;
816 bool bg_ignore_battery;
817 uint8_t bg_target;
818 uint32_t block_target;
819 uint64_t block_reward;
820 uint64_t difficulty;
821 std::string wide_difficulty;
822 uint64_t difficulty_top64;
823
824 BEGIN_KV_SERIALIZE_MAP()
825 KV_SERIALIZE_PARENT(rpc_response_base)
826 KV_SERIALIZE(active)
827 KV_SERIALIZE(speed)
828 KV_SERIALIZE(threads_count)
829 KV_SERIALIZE(address)
830 KV_SERIALIZE(pow_algorithm)
831 KV_SERIALIZE(is_background_mining_enabled)
832 KV_SERIALIZE(bg_idle_threshold)
833 KV_SERIALIZE(bg_min_idle_seconds)
834 KV_SERIALIZE(bg_ignore_battery)
835 KV_SERIALIZE(bg_target)
836 KV_SERIALIZE(block_target)
837 KV_SERIALIZE(block_reward)
838 KV_SERIALIZE(difficulty)
839 KV_SERIALIZE(wide_difficulty)
840 KV_SERIALIZE(difficulty_top64)
841 END_KV_SERIALIZE_MAP()
842 };
843 typedef epee::misc_utils::struct_init<response_t> response;
844 };
845
846 //-----------------------------------------------
847 struct COMMAND_RPC_SAVE_BC
848 {
849 struct request_t: public rpc_request_base
850 {
851 BEGIN_KV_SERIALIZE_MAP()
852 KV_SERIALIZE_PARENT(rpc_request_base)
853 END_KV_SERIALIZE_MAP()
854 };
855 typedef epee::misc_utils::struct_init<request_t> request;
856
857
858 struct response_t: public rpc_response_base
859 {
860 BEGIN_KV_SERIALIZE_MAP()
861 KV_SERIALIZE_PARENT(rpc_response_base)
862 END_KV_SERIALIZE_MAP()
863 };
864 typedef epee::misc_utils::struct_init<response_t> response;
865 };
866
867 //
868 struct COMMAND_RPC_GETBLOCKCOUNT
869 {
870 typedef std::list<std::string> request;
871
872 struct response_t: public rpc_response_base
873 {
874 uint64_t count;
875
876 BEGIN_KV_SERIALIZE_MAP()
877 KV_SERIALIZE_PARENT(rpc_response_base)
878 KV_SERIALIZE(count)
879 END_KV_SERIALIZE_MAP()
880 };
881 typedef epee::misc_utils::struct_init<response_t> response;
882 };
883
884 struct COMMAND_RPC_GETBLOCKHASH
885 {
886 typedef std::vector<uint64_t> request;
887
888 typedef std::string response;
889 };
890
891
892 struct COMMAND_RPC_GETBLOCKTEMPLATE
893 {
894 struct request_t: public rpc_request_base
895 {
896 uint64_t reserve_size; //max 255 bytes
897 std::string wallet_address;
898 std::string prev_block;
899 std::string extra_nonce;
900
901 BEGIN_KV_SERIALIZE_MAP()
902 KV_SERIALIZE_PARENT(rpc_request_base)
903 KV_SERIALIZE(reserve_size)
904 KV_SERIALIZE(wallet_address)
905 KV_SERIALIZE(prev_block)
906 KV_SERIALIZE(extra_nonce)
907 END_KV_SERIALIZE_MAP()
908 };
909 typedef epee::misc_utils::struct_init<request_t> request;
910
911 struct response_t: public rpc_response_base
912 {
913 uint64_t difficulty;
914 std::string wide_difficulty;
915 uint64_t difficulty_top64;
916 uint64_t height;
917 uint64_t reserved_offset;
918 uint64_t expected_reward;
919 std::string prev_hash;
920 uint64_t seed_height;
921 std::string seed_hash;
922 std::string next_seed_hash;
923 blobdata blocktemplate_blob;
924 blobdata blockhashing_blob;
925
926 BEGIN_KV_SERIALIZE_MAP()
927 KV_SERIALIZE_PARENT(rpc_response_base)
928 KV_SERIALIZE(difficulty)
929 KV_SERIALIZE(wide_difficulty)
930 KV_SERIALIZE(difficulty_top64)
931 KV_SERIALIZE(height)
932 KV_SERIALIZE(reserved_offset)
933 KV_SERIALIZE(expected_reward)
934 KV_SERIALIZE(prev_hash)
935 KV_SERIALIZE(seed_height)
936 KV_SERIALIZE(blocktemplate_blob)
937 KV_SERIALIZE(blockhashing_blob)
938 KV_SERIALIZE(seed_hash)
939 KV_SERIALIZE(next_seed_hash)
940 END_KV_SERIALIZE_MAP()
941 };
942 typedef epee::misc_utils::struct_init<response_t> response;
943 };
944
945 struct COMMAND_RPC_GETMINERDATA
946 {
947 struct request_t: public rpc_request_base
948 {
949 BEGIN_KV_SERIALIZE_MAP()
950 KV_SERIALIZE_PARENT(rpc_request_base)
951 END_KV_SERIALIZE_MAP()
952 };
953 typedef epee::misc_utils::struct_init<request_t> request;
954
955 struct response_t: public rpc_response_base
956 {
957 uint8_t major_version;
958 uint64_t height;
959 std::string prev_id;
960 std::string seed_hash;
961 std::string difficulty;
962 uint64_t median_weight;
963 uint64_t already_generated_coins;
964
965 struct tx_backlog_entry
966 {
967 std::string id;
968 uint64_t weight;
969 uint64_t fee;
970
971 BEGIN_KV_SERIALIZE_MAP()
972 KV_SERIALIZE(id)
973 KV_SERIALIZE(weight)
974 KV_SERIALIZE(fee)
975 END_KV_SERIALIZE_MAP()
976 };
977
978 std::vector<tx_backlog_entry> tx_backlog;
979
980 BEGIN_KV_SERIALIZE_MAP()
981 KV_SERIALIZE_PARENT(rpc_response_base)
982 KV_SERIALIZE(major_version)
983 KV_SERIALIZE(height)
984 KV_SERIALIZE(prev_id)
985 KV_SERIALIZE(seed_hash)
986 KV_SERIALIZE(difficulty)
987 KV_SERIALIZE(median_weight)
988 KV_SERIALIZE(already_generated_coins)
989 KV_SERIALIZE(tx_backlog)
990 END_KV_SERIALIZE_MAP()
991 };
992 typedef epee::misc_utils::struct_init<response_t> response;
993 };
994
995 struct COMMAND_RPC_CALCPOW
996 {
997 struct request_t: public rpc_request_base
998 {
999 uint8_t major_version;
1000 uint64_t height;
1001 blobdata block_blob;
1002 std::string seed_hash;
1003
1004 BEGIN_KV_SERIALIZE_MAP()
1005 KV_SERIALIZE_PARENT(rpc_request_base)
1006 KV_SERIALIZE(major_version)
1007 KV_SERIALIZE(height)
1008 KV_SERIALIZE(block_blob)
1009 KV_SERIALIZE(seed_hash)
1010 END_KV_SERIALIZE_MAP()
1011 };
1012 typedef epee::misc_utils::struct_init<request_t> request;
1013
1014 typedef std::string response;
1015 };
1016
1017 struct COMMAND_RPC_ADD_AUX_POW
1018 {
1019 struct aux_pow_t
1020 {
1021 std::string id;
1022 std::string hash;
1023
1024 BEGIN_KV_SERIALIZE_MAP()
1025 KV_SERIALIZE(id)
1026 KV_SERIALIZE(hash)
1027 END_KV_SERIALIZE_MAP()
1028 };
1029
1030 struct request_t: public rpc_request_base
1031 {
1032 blobdata blocktemplate_blob;
1033 std::vector<aux_pow_t> aux_pow;
1034
1035 BEGIN_KV_SERIALIZE_MAP()
1036 KV_SERIALIZE_PARENT(rpc_request_base)
1037 KV_SERIALIZE(blocktemplate_blob)
1038 KV_SERIALIZE(aux_pow)
1039 END_KV_SERIALIZE_MAP()
1040 };
1041 typedef epee::misc_utils::struct_init<request_t> request;
1042
1043 struct response_t: public rpc_response_base
1044 {
1045 blobdata blocktemplate_blob;
1046 blobdata blockhashing_blob;
1047 std::string merkle_root;
1048 uint32_t merkle_tree_depth;
1049 std::vector<aux_pow_t> aux_pow;
1050
1051 BEGIN_KV_SERIALIZE_MAP()
1052 KV_SERIALIZE_PARENT(rpc_response_base)
1053 KV_SERIALIZE(blocktemplate_blob)
1054 KV_SERIALIZE(blockhashing_blob)
1055 KV_SERIALIZE(merkle_root)
1056 KV_SERIALIZE(merkle_tree_depth)
1057 KV_SERIALIZE(aux_pow)
1058 END_KV_SERIALIZE_MAP()
1059 };
1060 typedef epee::misc_utils::struct_init<response_t> response;
1061 };
1062
1063 struct COMMAND_RPC_SUBMITBLOCK
1064 {
1065 typedef std::vector<std::string> request;
1066
1067 struct response_t: public rpc_response_base
1068 {
1069 BEGIN_KV_SERIALIZE_MAP()
1070 KV_SERIALIZE_PARENT(rpc_response_base)
1071 END_KV_SERIALIZE_MAP()
1072 };
1073 typedef epee::misc_utils::struct_init<response_t> response;
1074 };
1075
1076 struct COMMAND_RPC_GENERATEBLOCKS
1077 {
1078 struct request_t: public rpc_request_base
1079 {
1080 uint64_t amount_of_blocks;
1081 std::string wallet_address;
1082 std::string prev_block;
1083 uint32_t starting_nonce;
1084
1085 BEGIN_KV_SERIALIZE_MAP()
1086 KV_SERIALIZE_PARENT(rpc_request_base)
1087 KV_SERIALIZE(amount_of_blocks)
1088 KV_SERIALIZE(wallet_address)
1089 KV_SERIALIZE(prev_block)
1090 KV_SERIALIZE_OPT(starting_nonce, (uint32_t)0)
1091 END_KV_SERIALIZE_MAP()
1092 };
1093 typedef epee::misc_utils::struct_init<request_t> request;
1094
1095 struct response_t: public rpc_response_base
1096 {
1097 uint64_t height;
1098 std::vector<std::string> blocks;
1099
1100 BEGIN_KV_SERIALIZE_MAP()
1101 KV_SERIALIZE_PARENT(rpc_response_base)
1102 KV_SERIALIZE(height)
1103 KV_SERIALIZE(blocks)
1104 END_KV_SERIALIZE_MAP()
1105 };
1106 typedef epee::misc_utils::struct_init<response_t> response;
1107 };
1108
1109 struct block_header_response
1110 {
1111 uint8_t major_version;
1112 uint8_t minor_version;
1113 uint64_t timestamp;
1114 std::string prev_hash;
1115 uint32_t nonce;
1116 bool orphan_status;
1117 uint64_t height;
1118 uint64_t depth;
1119 std::string hash;
1120 uint64_t difficulty;
1121 std::string wide_difficulty;
1122 uint64_t difficulty_top64;
1123 uint64_t cumulative_difficulty;
1124 std::string wide_cumulative_difficulty;
1125 uint64_t cumulative_difficulty_top64;
1126 uint64_t reward;
1127 uint64_t block_size;
1128 uint64_t block_weight;
1129 uint64_t num_txes;
1130 std::string pow_hash;
1131 uint64_t long_term_weight;
1132 std::string miner_tx_hash;
1133
1134 BEGIN_KV_SERIALIZE_MAP()
1135 KV_SERIALIZE(major_version)
1136 KV_SERIALIZE(minor_version)
1137 KV_SERIALIZE(timestamp)
1138 KV_SERIALIZE(prev_hash)
1139 KV_SERIALIZE(nonce)
1140 KV_SERIALIZE(orphan_status)
1141 KV_SERIALIZE(height)
1142 KV_SERIALIZE(depth)
1143 KV_SERIALIZE(hash)
1144 KV_SERIALIZE(difficulty)
1145 KV_SERIALIZE(wide_difficulty)
1146 KV_SERIALIZE(difficulty_top64)
1147 KV_SERIALIZE(cumulative_difficulty)
1148 KV_SERIALIZE(wide_cumulative_difficulty)
1149 KV_SERIALIZE(cumulative_difficulty_top64)
1150 KV_SERIALIZE(reward)
1151 KV_SERIALIZE(block_size)
1152 KV_SERIALIZE_OPT(block_weight, (uint64_t)0)
1153 KV_SERIALIZE(num_txes)
1154 KV_SERIALIZE(pow_hash)
1155 KV_SERIALIZE_OPT(long_term_weight, (uint64_t)0)
1156 KV_SERIALIZE(miner_tx_hash)
1157 END_KV_SERIALIZE_MAP()
1158 };
1159
1160 struct COMMAND_RPC_GET_LAST_BLOCK_HEADER
1161 {
1162 struct request_t: public rpc_access_request_base
1163 {
1164 bool fill_pow_hash;
1165
1166 BEGIN_KV_SERIALIZE_MAP()
1167 KV_SERIALIZE_PARENT(rpc_access_request_base)
1168 KV_SERIALIZE_OPT(fill_pow_hash, false);
1169 END_KV_SERIALIZE_MAP()
1170 };
1171 typedef epee::misc_utils::struct_init<request_t> request;
1172
1173 struct response_t: public rpc_access_response_base
1174 {
1175 block_header_response block_header;
1176
1177 BEGIN_KV_SERIALIZE_MAP()
1178 KV_SERIALIZE_PARENT(rpc_access_response_base)
1179 KV_SERIALIZE(block_header)
1180 END_KV_SERIALIZE_MAP()
1181 };
1182 typedef epee::misc_utils::struct_init<response_t> response;
1183
1184 };
1185
1186 struct COMMAND_RPC_GET_BLOCK_HEADER_BY_HASH
1187 {
1188 struct request_t: public rpc_access_request_base
1189 {
1190 std::string hash;
1191 std::vector<std::string> hashes;
1192 bool fill_pow_hash;
1193
1194 BEGIN_KV_SERIALIZE_MAP()
1195 KV_SERIALIZE_PARENT(rpc_access_request_base)
1196 KV_SERIALIZE(hash)
1197 KV_SERIALIZE(hashes)
1198 KV_SERIALIZE_OPT(fill_pow_hash, false);
1199 END_KV_SERIALIZE_MAP()
1200 };
1201 typedef epee::misc_utils::struct_init<request_t> request;
1202
1203 struct response_t: public rpc_access_response_base
1204 {
1205 block_header_response block_header;
1206 std::vector<block_header_response> block_headers;
1207
1208 BEGIN_KV_SERIALIZE_MAP()
1209 KV_SERIALIZE_PARENT(rpc_access_response_base)
1210 KV_SERIALIZE(block_header)
1211 KV_SERIALIZE(block_headers)
1212 END_KV_SERIALIZE_MAP()
1213 };
1214 typedef epee::misc_utils::struct_init<response_t> response;
1215 };
1216
1217 struct COMMAND_RPC_GET_BLOCK_HEADER_BY_HEIGHT
1218 {
1219 struct request_t: public rpc_access_request_base
1220 {
1221 uint64_t height;
1222 bool fill_pow_hash;
1223
1224 BEGIN_KV_SERIALIZE_MAP()
1225 KV_SERIALIZE_PARENT(rpc_access_request_base)
1226 KV_SERIALIZE(height)
1227 KV_SERIALIZE_OPT(fill_pow_hash, false);
1228 END_KV_SERIALIZE_MAP()
1229 };
1230 typedef epee::misc_utils::struct_init<request_t> request;
1231
1232 struct response_t: public rpc_access_response_base
1233 {
1234 block_header_response block_header;
1235
1236 BEGIN_KV_SERIALIZE_MAP()
1237 KV_SERIALIZE_PARENT(rpc_access_response_base)
1238 KV_SERIALIZE(block_header)
1239 END_KV_SERIALIZE_MAP()
1240 };
1241 typedef epee::misc_utils::struct_init<response_t> response;
1242 };
1243
1244 struct COMMAND_RPC_GET_BLOCK
1245 {
1246 struct request_t: public rpc_access_request_base
1247 {
1248 std::string hash;
1249 uint64_t height;
1250 bool fill_pow_hash;
1251
1252 BEGIN_KV_SERIALIZE_MAP()
1253 KV_SERIALIZE_PARENT(rpc_access_request_base)
1254 KV_SERIALIZE(hash)
1255 KV_SERIALIZE(height)
1256 KV_SERIALIZE_OPT(fill_pow_hash, false);
1257 END_KV_SERIALIZE_MAP()
1258 };
1259 typedef epee::misc_utils::struct_init<request_t> request;
1260
1261 struct response_t: public rpc_access_response_base
1262 {
1263 block_header_response block_header;
1264 std::string miner_tx_hash;
1265 std::vector<std::string> tx_hashes;
1266 std::string blob;
1267 std::string json;
1268
1269 BEGIN_KV_SERIALIZE_MAP()
1270 KV_SERIALIZE_PARENT(rpc_access_response_base)
1271 KV_SERIALIZE(block_header)
1272 KV_SERIALIZE(miner_tx_hash)
1273 KV_SERIALIZE(tx_hashes)
1274 KV_SERIALIZE(blob)
1275 KV_SERIALIZE(json)
1276 END_KV_SERIALIZE_MAP()
1277 };
1278 typedef epee::misc_utils::struct_init<response_t> response;
1279 };
1280
1281 struct peer {
1282 uint64_t id;
1283 std::string host;
1284 uint32_t ip;
1285 uint16_t port;
1286 uint16_t rpc_port;
1287 uint32_t rpc_credits_per_hash;
1288 uint64_t last_seen;
1289 uint32_t pruning_seed;
1290
1291 peer() = default;
1292
1293 peer(uint64_t id, const std::string &host, uint64_t last_seen, uint32_t pruning_seed, uint16_t rpc_port, uint32_t rpc_credits_per_hash)
1294 : id(id), host(host), ip(0), port(0), rpc_port(rpc_port), rpc_credits_per_hash(rpc_credits_per_hash), last_seen(last_seen), pruning_seed(pruning_seed)
1295 {}
1296 peer(uint64_t id, const std::string &host, uint16_t port, uint64_t last_seen, uint32_t pruning_seed, uint16_t rpc_port, uint32_t rpc_credits_per_hash)
1297 : id(id), host(host), ip(0), port(port), rpc_port(rpc_port), rpc_credits_per_hash(rpc_credits_per_hash), last_seen(last_seen), pruning_seed(pruning_seed)
1298 {}
1299 peer(uint64_t id, uint32_t ip, uint16_t port, uint64_t last_seen, uint32_t pruning_seed, uint16_t rpc_port, uint32_t rpc_credits_per_hash)
1300 : id(id), host(epee::string_tools::get_ip_string_from_int32(ip)), ip(ip), port(port), rpc_port(rpc_port), rpc_credits_per_hash(rpc_credits_per_hash), last_seen(last_seen), pruning_seed(pruning_seed)
1301 {}
1302
1303 BEGIN_KV_SERIALIZE_MAP()
1304 KV_SERIALIZE(id)
1305 KV_SERIALIZE(host)
1306 KV_SERIALIZE(ip)
1307 KV_SERIALIZE(port)
1308 KV_SERIALIZE_OPT(rpc_port, (uint16_t)0)
1309 KV_SERIALIZE_OPT(rpc_credits_per_hash, (uint32_t)0)
1310 KV_SERIALIZE(last_seen)
1311 KV_SERIALIZE_OPT(pruning_seed, (uint32_t)0)
1312 END_KV_SERIALIZE_MAP()
1313 };
1314
1315 struct COMMAND_RPC_GET_PEER_LIST
1316 {
1317 struct request_t: public rpc_request_base
1318 {
1319 bool public_only;
1320 bool include_blocked;
1321
1322 BEGIN_KV_SERIALIZE_MAP()
1323 KV_SERIALIZE_PARENT(rpc_request_base)
1324 KV_SERIALIZE_OPT(public_only, true)
1325 KV_SERIALIZE_OPT(include_blocked, false)
1326 END_KV_SERIALIZE_MAP()
1327 };
1328 typedef epee::misc_utils::struct_init<request_t> request;
1329
1330 struct response_t: public rpc_response_base
1331 {
1332 std::vector<peer> white_list;
1333 std::vector<peer> gray_list;
1334
1335 BEGIN_KV_SERIALIZE_MAP()
1336 KV_SERIALIZE_PARENT(rpc_response_base)
1337 KV_SERIALIZE(white_list)
1338 KV_SERIALIZE(gray_list)
1339 END_KV_SERIALIZE_MAP()
1340 };
1341 typedef epee::misc_utils::struct_init<response_t> response;
1342 };
1343
1344 struct public_node
1345 {
1346 std::string host;
1347 uint64_t last_seen;
1348 uint16_t rpc_port;
1349 uint32_t rpc_credits_per_hash;
1350
1351 public_node(): last_seen(0), rpc_port(0), rpc_credits_per_hash(0) {}
1352
1353 public_node(const peer &peer)
1354 : host(peer.host), last_seen(peer.last_seen), rpc_port(peer.rpc_port), rpc_credits_per_hash(peer.rpc_credits_per_hash)
1355 {}
1356
1357 BEGIN_KV_SERIALIZE_MAP()
1358 KV_SERIALIZE(host)
1359 KV_SERIALIZE(last_seen)
1360 KV_SERIALIZE(rpc_port)
1361 KV_SERIALIZE(rpc_credits_per_hash)
1362 END_KV_SERIALIZE_MAP()
1363 };
1364
1365 struct COMMAND_RPC_GET_PUBLIC_NODES
1366 {
1367 struct request_t: public rpc_request_base
1368 {
1369 bool gray;
1370 bool white;
1371 bool include_blocked;
1372
1373 BEGIN_KV_SERIALIZE_MAP()
1374 KV_SERIALIZE_PARENT(rpc_request_base)
1375 KV_SERIALIZE_OPT(gray, false)
1376 KV_SERIALIZE_OPT(white, true)
1377 KV_SERIALIZE_OPT(include_blocked, false)
1378 END_KV_SERIALIZE_MAP()
1379 };
1380 typedef epee::misc_utils::struct_init<request_t> request;
1381
1382 struct response_t: public rpc_response_base
1383 {
1384 std::vector<public_node> gray;
1385 std::vector<public_node> white;
1386
1387 BEGIN_KV_SERIALIZE_MAP()
1388 KV_SERIALIZE_PARENT(rpc_response_base)
1389 KV_SERIALIZE(gray)
1390 KV_SERIALIZE(white)
1391 END_KV_SERIALIZE_MAP()
1392 };
1393 typedef epee::misc_utils::struct_init<response_t> response;
1394 };
1395
1396 struct COMMAND_RPC_SET_LOG_HASH_RATE
1397 {
1398 struct request_t: public rpc_request_base
1399 {
1400 bool visible;
1401
1402 BEGIN_KV_SERIALIZE_MAP()
1403 KV_SERIALIZE_PARENT(rpc_request_base)
1404 KV_SERIALIZE(visible)
1405 END_KV_SERIALIZE_MAP()
1406 };
1407 typedef epee::misc_utils::struct_init<request_t> request;
1408
1409 struct response_t: public rpc_response_base
1410 {
1411 BEGIN_KV_SERIALIZE_MAP()
1412 KV_SERIALIZE_PARENT(rpc_response_base)
1413 END_KV_SERIALIZE_MAP()
1414 };
1415 typedef epee::misc_utils::struct_init<response_t> response;
1416 };
1417
1418 struct COMMAND_RPC_SET_LOG_LEVEL
1419 {
1420 struct request_t: public rpc_request_base
1421 {
1422 int8_t level;
1423
1424 BEGIN_KV_SERIALIZE_MAP()
1425 KV_SERIALIZE_PARENT(rpc_request_base)
1426 KV_SERIALIZE(level)
1427 END_KV_SERIALIZE_MAP()
1428 };
1429 typedef epee::misc_utils::struct_init<request_t> request;
1430
1431 struct response_t: public rpc_response_base
1432 {
1433 BEGIN_KV_SERIALIZE_MAP()
1434 KV_SERIALIZE_PARENT(rpc_response_base)
1435 END_KV_SERIALIZE_MAP()
1436 };
1437 typedef epee::misc_utils::struct_init<response_t> response;
1438 };
1439
1440 struct COMMAND_RPC_SET_LOG_CATEGORIES
1441 {
1442 struct request_t: public rpc_request_base
1443 {
1444 std::string categories;
1445
1446 BEGIN_KV_SERIALIZE_MAP()
1447 KV_SERIALIZE_PARENT(rpc_request_base)
1448 KV_SERIALIZE(categories)
1449 END_KV_SERIALIZE_MAP()
1450 };
1451 typedef epee::misc_utils::struct_init<request_t> request;
1452
1453 struct response_t: public rpc_response_base
1454 {
1455 std::string categories;
1456
1457 BEGIN_KV_SERIALIZE_MAP()
1458 KV_SERIALIZE_PARENT(rpc_response_base)
1459 KV_SERIALIZE(categories)
1460 END_KV_SERIALIZE_MAP()
1461 };
1462 typedef epee::misc_utils::struct_init<response_t> response;
1463 };
1464
1465 struct tx_info
1466 {
1467 std::string id_hash;
1468 std::string tx_json; // TODO - expose this data directly
1469 uint64_t blob_size;
1470 uint64_t weight;
1471 uint64_t fee;
1472 std::string max_used_block_id_hash;
1473 uint64_t max_used_block_height;
1474 bool kept_by_block;
1475 uint64_t last_failed_height;
1476 std::string last_failed_id_hash;
1477 uint64_t receive_time;
1478 bool relayed;
1479 uint64_t last_relayed_time;
1480 bool do_not_relay;
1481 bool double_spend_seen;
1482 std::string tx_blob;
1483
1484 BEGIN_KV_SERIALIZE_MAP()
1485 KV_SERIALIZE(id_hash)
1486 KV_SERIALIZE(tx_json)
1487 KV_SERIALIZE(blob_size)
1488 KV_SERIALIZE_OPT(weight, (uint64_t)0)
1489 KV_SERIALIZE(fee)
1490 KV_SERIALIZE(max_used_block_id_hash)
1491 KV_SERIALIZE(max_used_block_height)
1492 KV_SERIALIZE(kept_by_block)
1493 KV_SERIALIZE(last_failed_height)
1494 KV_SERIALIZE(last_failed_id_hash)
1495 KV_SERIALIZE(receive_time)
1496 KV_SERIALIZE(relayed)
1497 KV_SERIALIZE(last_relayed_time)
1498 KV_SERIALIZE(do_not_relay)
1499 KV_SERIALIZE(double_spend_seen)
1500 KV_SERIALIZE(tx_blob)
1501 END_KV_SERIALIZE_MAP()
1502 };
1503
1504 struct spent_key_image_info
1505 {
1506 std::string id_hash;
1507 std::vector<std::string> txs_hashes;
1508
1509 BEGIN_KV_SERIALIZE_MAP()
1510 KV_SERIALIZE(id_hash)
1511 KV_SERIALIZE(txs_hashes)
1512 END_KV_SERIALIZE_MAP()
1513 };
1514
1515 struct COMMAND_RPC_GET_TRANSACTION_POOL
1516 {
1517 struct request_t: public rpc_access_request_base
1518 {
1519 BEGIN_KV_SERIALIZE_MAP()
1520 KV_SERIALIZE_PARENT(rpc_access_request_base)
1521 END_KV_SERIALIZE_MAP()
1522 };
1523 typedef epee::misc_utils::struct_init<request_t> request;
1524
1525 struct response_t: public rpc_access_response_base
1526 {
1527 std::vector<tx_info> transactions;
1528 std::vector<spent_key_image_info> spent_key_images;
1529
1530 BEGIN_KV_SERIALIZE_MAP()
1531 KV_SERIALIZE_PARENT(rpc_access_response_base)
1532 KV_SERIALIZE(transactions)
1533 KV_SERIALIZE(spent_key_images)
1534 END_KV_SERIALIZE_MAP()
1535 };
1536 typedef epee::misc_utils::struct_init<response_t> response;
1537 };
1538
1539 struct COMMAND_RPC_GET_TRANSACTION_POOL_HASHES_BIN
1540 {
1541 struct request_t: public rpc_access_request_base
1542 {
1543 BEGIN_KV_SERIALIZE_MAP()
1544 KV_SERIALIZE_PARENT(rpc_access_request_base)
1545 END_KV_SERIALIZE_MAP()
1546 };
1547 typedef epee::misc_utils::struct_init<request_t> request;
1548
1549 struct response_t: public rpc_access_response_base
1550 {
1551 std::vector<crypto::hash> tx_hashes;
1552
1553 BEGIN_KV_SERIALIZE_MAP()
1554 KV_SERIALIZE_PARENT(rpc_access_response_base)
1555 KV_SERIALIZE_CONTAINER_POD_AS_BLOB(tx_hashes)
1556 END_KV_SERIALIZE_MAP()
1557 };
1558 typedef epee::misc_utils::struct_init<response_t> response;
1559 };
1560
1561 struct COMMAND_RPC_GET_TRANSACTION_POOL_HASHES
1562 {
1563 struct request_t: public rpc_access_request_base
1564 {
1565 BEGIN_KV_SERIALIZE_MAP()
1566 KV_SERIALIZE_PARENT(rpc_access_request_base)
1567 END_KV_SERIALIZE_MAP()
1568 };
1569 typedef epee::misc_utils::struct_init<request_t> request;
1570
1571 struct response_t: public rpc_access_response_base
1572 {
1573 std::vector<std::string> tx_hashes;
1574
1575 BEGIN_KV_SERIALIZE_MAP()
1576 KV_SERIALIZE_PARENT(rpc_access_response_base)
1577 KV_SERIALIZE(tx_hashes)
1578 END_KV_SERIALIZE_MAP()
1579 };
1580 typedef epee::misc_utils::struct_init<response_t> response;
1581 };
1582
1583 struct tx_backlog_entry
1584 {
1585 uint64_t weight;
1586 uint64_t fee;
1587 uint64_t time_in_pool;
1588 };
1589
1590 struct COMMAND_RPC_GET_TRANSACTION_POOL_BACKLOG
1591 {
1592 struct request_t: public rpc_access_request_base
1593 {
1594 BEGIN_KV_SERIALIZE_MAP()
1595 KV_SERIALIZE_PARENT(rpc_access_request_base)
1596 END_KV_SERIALIZE_MAP()
1597 };
1598 typedef epee::misc_utils::struct_init<request_t> request;
1599
1600 struct response_t: public rpc_access_response_base
1601 {
1602 std::vector<tx_backlog_entry> backlog;
1603
1604 BEGIN_KV_SERIALIZE_MAP()
1605 KV_SERIALIZE_PARENT(rpc_access_response_base)
1606 KV_SERIALIZE_CONTAINER_POD_AS_BLOB(backlog)
1607 END_KV_SERIALIZE_MAP()
1608 };
1609 typedef epee::misc_utils::struct_init<response_t> response;
1610 };
1611
1612 struct txpool_histo
1613 {
1614 uint32_t txs;
1615 uint64_t bytes;
1616
1617 BEGIN_KV_SERIALIZE_MAP()
1618 KV_SERIALIZE(txs)
1619 KV_SERIALIZE(bytes)
1620 END_KV_SERIALIZE_MAP()
1621 };
1622
1623 struct txpool_stats
1624 {
1625 uint64_t bytes_total;
1626 uint32_t bytes_min;
1627 uint32_t bytes_max;
1628 uint32_t bytes_med;
1629 uint64_t fee_total;
1630 uint64_t oldest;
1631 uint32_t txs_total;
1632 uint32_t num_failing;
1633 uint32_t num_10m;
1634 uint32_t num_not_relayed;
1635 uint64_t histo_98pc;
1636 std::vector<txpool_histo> histo;
1637 uint32_t num_double_spends;
1638
1639 txpool_stats(): bytes_total(0), bytes_min(0), bytes_max(0), bytes_med(0), fee_total(0), oldest(0), txs_total(0), num_failing(0), num_10m(0), num_not_relayed(0), histo_98pc(0), num_double_spends(0) {}
1640
1641 BEGIN_KV_SERIALIZE_MAP()
1642 KV_SERIALIZE(bytes_total)
1643 KV_SERIALIZE(bytes_min)
1644 KV_SERIALIZE(bytes_max)
1645 KV_SERIALIZE(bytes_med)
1646 KV_SERIALIZE(fee_total)
1647 KV_SERIALIZE(oldest)
1648 KV_SERIALIZE(txs_total)
1649 KV_SERIALIZE(num_failing)
1650 KV_SERIALIZE(num_10m)
1651 KV_SERIALIZE(num_not_relayed)
1652 KV_SERIALIZE(histo_98pc)
1653 KV_SERIALIZE(histo)
1654 KV_SERIALIZE(num_double_spends)
1655 END_KV_SERIALIZE_MAP()
1656 };
1657
1658 struct COMMAND_RPC_GET_TRANSACTION_POOL_STATS
1659 {
1660 struct request_t: public rpc_access_request_base
1661 {
1662 BEGIN_KV_SERIALIZE_MAP()
1663 KV_SERIALIZE_PARENT(rpc_access_request_base)
1664 END_KV_SERIALIZE_MAP()
1665 };
1666 typedef epee::misc_utils::struct_init<request_t> request;
1667
1668 struct response_t: public rpc_access_response_base
1669 {
1670 txpool_stats pool_stats;
1671
1672 BEGIN_KV_SERIALIZE_MAP()
1673 KV_SERIALIZE_PARENT(rpc_access_response_base)
1674 KV_SERIALIZE(pool_stats)
1675 END_KV_SERIALIZE_MAP()
1676 };
1677 typedef epee::misc_utils::struct_init<response_t> response;
1678 };
1679
1680 struct COMMAND_RPC_GET_CONNECTIONS
1681 {
1682 struct request_t: public rpc_request_base
1683 {
1684 BEGIN_KV_SERIALIZE_MAP()
1685 KV_SERIALIZE_PARENT(rpc_request_base)
1686 END_KV_SERIALIZE_MAP()
1687 };
1688 typedef epee::misc_utils::struct_init<request_t> request;
1689
1690 struct response_t: public rpc_response_base
1691 {
1692 std::list<connection_info> connections;
1693
1694 BEGIN_KV_SERIALIZE_MAP()
1695 KV_SERIALIZE_PARENT(rpc_response_base)
1696 KV_SERIALIZE(connections)
1697 END_KV_SERIALIZE_MAP()
1698 };
1699 typedef epee::misc_utils::struct_init<response_t> response;
1700 };
1701
1702 struct COMMAND_RPC_GET_BLOCK_HEADERS_RANGE
1703 {
1704 struct request_t: public rpc_access_request_base
1705 {
1706 uint64_t start_height;
1707 uint64_t end_height;
1708 bool fill_pow_hash;
1709
1710 BEGIN_KV_SERIALIZE_MAP()
1711 KV_SERIALIZE_PARENT(rpc_access_request_base)
1712 KV_SERIALIZE(start_height)
1713 KV_SERIALIZE(end_height)
1714 KV_SERIALIZE_OPT(fill_pow_hash, false);
1715 END_KV_SERIALIZE_MAP()
1716 };
1717 typedef epee::misc_utils::struct_init<request_t> request;
1718
1719 struct response_t: public rpc_access_response_base
1720 {
1721 std::vector<block_header_response> headers;
1722
1723 BEGIN_KV_SERIALIZE_MAP()
1724 KV_SERIALIZE_PARENT(rpc_access_response_base)
1725 KV_SERIALIZE(headers)
1726 END_KV_SERIALIZE_MAP()
1727 };
1728 typedef epee::misc_utils::struct_init<response_t> response;
1729 };
1730
1731 struct COMMAND_RPC_SET_BOOTSTRAP_DAEMON
1732 {
1733 struct request_t
1734 {
1735 std::string address;
1736 std::string username;
1737 std::string password;
1738 std::string proxy;
1739
1740 BEGIN_KV_SERIALIZE_MAP()
1741 KV_SERIALIZE(address)
1742 KV_SERIALIZE(username)
1743 KV_SERIALIZE(password)
1744 KV_SERIALIZE(proxy)
1745 END_KV_SERIALIZE_MAP()
1746 };
1747 typedef epee::misc_utils::struct_init<request_t> request;
1748
1749 struct response_t
1750 {
1751 std::string status;
1752
1753 BEGIN_KV_SERIALIZE_MAP()
1754 KV_SERIALIZE(status)
1755 END_KV_SERIALIZE_MAP()
1756 };
1757 typedef epee::misc_utils::struct_init<response_t> response;
1758 };
1759
1760 struct COMMAND_RPC_STOP_DAEMON
1761 {
1762 struct request_t: public rpc_request_base
1763 {
1764 BEGIN_KV_SERIALIZE_MAP()
1765 KV_SERIALIZE_PARENT(rpc_request_base)
1766 END_KV_SERIALIZE_MAP()
1767 };
1768 typedef epee::misc_utils::struct_init<request_t> request;
1769
1770 struct response_t: public rpc_response_base
1771 {
1772 BEGIN_KV_SERIALIZE_MAP()
1773 KV_SERIALIZE_PARENT(rpc_response_base)
1774 END_KV_SERIALIZE_MAP()
1775 };
1776 typedef epee::misc_utils::struct_init<response_t> response;
1777 };
1778
1779 struct COMMAND_RPC_FAST_EXIT
1780 {
1781 struct request_t: public rpc_request_base
1782 {
1783 BEGIN_KV_SERIALIZE_MAP()
1784 KV_SERIALIZE_PARENT(rpc_request_base)
1785 END_KV_SERIALIZE_MAP()
1786 };
1787 typedef epee::misc_utils::struct_init<request_t> request;
1788
1789 struct response_t: public rpc_response_base
1790 {
1791 BEGIN_KV_SERIALIZE_MAP()
1792 KV_SERIALIZE_PARENT(rpc_response_base)
1793 END_KV_SERIALIZE_MAP()
1794 };
1795 typedef epee::misc_utils::struct_init<response_t> response;
1796 };
1797
1798 struct COMMAND_RPC_GET_LIMIT
1799 {
1800 struct request_t: public rpc_request_base
1801 {
1802 BEGIN_KV_SERIALIZE_MAP()
1803 KV_SERIALIZE_PARENT(rpc_request_base)
1804 END_KV_SERIALIZE_MAP()
1805 };
1806 typedef epee::misc_utils::struct_init<request_t> request;
1807
1808 struct response_t: public rpc_response_base
1809 {
1810 uint64_t limit_up;
1811 uint64_t limit_down;
1812
1813 BEGIN_KV_SERIALIZE_MAP()
1814 KV_SERIALIZE_PARENT(rpc_response_base)
1815 KV_SERIALIZE(limit_up)
1816 KV_SERIALIZE(limit_down)
1817 END_KV_SERIALIZE_MAP()
1818 };
1819 typedef epee::misc_utils::struct_init<response_t> response;
1820 };
1821
1822 struct COMMAND_RPC_SET_LIMIT
1823 {
1824 struct request_t: public rpc_request_base
1825 {
1826 int64_t limit_down; // all limits (for get and set) are kB/s
1827 int64_t limit_up;
1828
1829 BEGIN_KV_SERIALIZE_MAP()
1830 KV_SERIALIZE_PARENT(rpc_request_base)
1831 KV_SERIALIZE(limit_down)
1832 KV_SERIALIZE(limit_up)
1833 END_KV_SERIALIZE_MAP()
1834 };
1835 typedef epee::misc_utils::struct_init<request_t> request;
1836
1837 struct response_t: public rpc_response_base
1838 {
1839 int64_t limit_up;
1840 int64_t limit_down;
1841
1842 BEGIN_KV_SERIALIZE_MAP()
1843 KV_SERIALIZE_PARENT(rpc_response_base)
1844 KV_SERIALIZE(limit_up)
1845 KV_SERIALIZE(limit_down)
1846 END_KV_SERIALIZE_MAP()
1847 };
1848 typedef epee::misc_utils::struct_init<response_t> response;
1849 };
1850
1851 struct COMMAND_RPC_OUT_PEERS
1852 {
1853 struct request_t: public rpc_request_base
1854 {
1855 bool set;
1856 uint32_t out_peers;
1857
1858 BEGIN_KV_SERIALIZE_MAP()
1859 KV_SERIALIZE_PARENT(rpc_request_base)
1860 KV_SERIALIZE_OPT(set, true)
1861 KV_SERIALIZE(out_peers)
1862 END_KV_SERIALIZE_MAP()
1863 };
1864 typedef epee::misc_utils::struct_init<request_t> request;
1865
1866 struct response_t: public rpc_response_base
1867 {
1868 uint32_t out_peers;
1869
1870 BEGIN_KV_SERIALIZE_MAP()
1871 KV_SERIALIZE_PARENT(rpc_response_base)
1872 KV_SERIALIZE(out_peers)
1873 END_KV_SERIALIZE_MAP()
1874 };
1875 typedef epee::misc_utils::struct_init<response_t> response;
1876 };
1877
1878 struct COMMAND_RPC_IN_PEERS
1879 {
1880 struct request_t: public rpc_request_base
1881 {
1882 bool set;
1883 uint32_t in_peers;
1884 BEGIN_KV_SERIALIZE_MAP()
1885 KV_SERIALIZE_PARENT(rpc_request_base)
1886 KV_SERIALIZE_OPT(set, true)
1887 KV_SERIALIZE(in_peers)
1888 END_KV_SERIALIZE_MAP()
1889 };
1890 typedef epee::misc_utils::struct_init<request_t> request;
1891
1892 struct response_t: public rpc_response_base
1893 {
1894 uint32_t in_peers;
1895
1896 BEGIN_KV_SERIALIZE_MAP()
1897 KV_SERIALIZE_PARENT(rpc_response_base)
1898 KV_SERIALIZE(in_peers)
1899 END_KV_SERIALIZE_MAP()
1900 };
1901 typedef epee::misc_utils::struct_init<response_t> response;
1902 };
1903
1904 struct COMMAND_RPC_HARD_FORK_INFO
1905 {
1906 struct request_t: public rpc_access_request_base
1907 {
1908 uint8_t version;
1909
1910 BEGIN_KV_SERIALIZE_MAP()
1911 KV_SERIALIZE_PARENT(rpc_access_request_base)
1912 KV_SERIALIZE(version)
1913 END_KV_SERIALIZE_MAP()
1914 };
1915 typedef epee::misc_utils::struct_init<request_t> request;
1916
1917 struct response_t: public rpc_access_response_base
1918 {
1919 uint8_t version;
1920 bool enabled;
1921 uint32_t window;
1922 uint32_t votes;
1923 uint32_t threshold;
1924 uint8_t voting;
1925 uint32_t state;
1926 uint64_t earliest_height;
1927
1928 BEGIN_KV_SERIALIZE_MAP()
1929 KV_SERIALIZE_PARENT(rpc_access_response_base)
1930 KV_SERIALIZE(version)
1931 KV_SERIALIZE(enabled)
1932 KV_SERIALIZE(window)
1933 KV_SERIALIZE(votes)
1934 KV_SERIALIZE(threshold)
1935 KV_SERIALIZE(voting)
1936 KV_SERIALIZE(state)
1937 KV_SERIALIZE(earliest_height)
1938 END_KV_SERIALIZE_MAP()
1939 };
1940 typedef epee::misc_utils::struct_init<response_t> response;
1941 };
1942
1943 struct COMMAND_RPC_GETBANS
1944 {
1945 struct ban
1946 {
1947 std::string host;
1948 uint32_t ip;
1949 uint32_t seconds;
1950
1951 BEGIN_KV_SERIALIZE_MAP()
1952 KV_SERIALIZE(host)
1953 KV_SERIALIZE(ip)
1954 KV_SERIALIZE(seconds)
1955 END_KV_SERIALIZE_MAP()
1956 };
1957
1958 struct request_t: public rpc_request_base
1959 {
1960 BEGIN_KV_SERIALIZE_MAP()
1961 KV_SERIALIZE_PARENT(rpc_request_base)
1962 END_KV_SERIALIZE_MAP()
1963 };
1964 typedef epee::misc_utils::struct_init<request_t> request;
1965
1966 struct response_t: public rpc_response_base
1967 {
1968 std::vector<ban> bans;
1969
1970 BEGIN_KV_SERIALIZE_MAP()
1971 KV_SERIALIZE_PARENT(rpc_response_base)
1972 KV_SERIALIZE(bans)
1973 END_KV_SERIALIZE_MAP()
1974 };
1975 typedef epee::misc_utils::struct_init<response_t> response;
1976 };
1977
1978 struct COMMAND_RPC_SETBANS
1979 {
1980 struct ban
1981 {
1982 std::string host;
1983 uint32_t ip;
1984 bool ban;
1985 uint32_t seconds;
1986
1987 BEGIN_KV_SERIALIZE_MAP()
1988 KV_SERIALIZE(host)
1989 KV_SERIALIZE(ip)
1990 KV_SERIALIZE(ban)
1991 KV_SERIALIZE(seconds)
1992 END_KV_SERIALIZE_MAP()
1993 };
1994
1995 struct request_t: public rpc_request_base
1996 {
1997 std::vector<ban> bans;
1998
1999 BEGIN_KV_SERIALIZE_MAP()
2000 KV_SERIALIZE_PARENT(rpc_request_base)
2001 KV_SERIALIZE(bans)
2002 END_KV_SERIALIZE_MAP()
2003 };
2004 typedef epee::misc_utils::struct_init<request_t> request;
2005
2006 struct response_t: public rpc_response_base
2007 {
2008 BEGIN_KV_SERIALIZE_MAP()
2009 KV_SERIALIZE_PARENT(rpc_response_base)
2010 END_KV_SERIALIZE_MAP()
2011 };
2012 typedef epee::misc_utils::struct_init<response_t> response;
2013 };
2014
2015 struct COMMAND_RPC_BANNED
2016 {
2017 struct request_t
2018 {
2019 std::string address;
2020
2021 BEGIN_KV_SERIALIZE_MAP()
2022 KV_SERIALIZE(address)
2023 END_KV_SERIALIZE_MAP()
2024 };
2025 typedef epee::misc_utils::struct_init<request_t> request;
2026
2027 struct response_t
2028 {
2029 std::string status;
2030 bool banned;
2031 uint32_t seconds;
2032
2033 BEGIN_KV_SERIALIZE_MAP()
2034 KV_SERIALIZE(status)
2035 KV_SERIALIZE(banned)
2036 KV_SERIALIZE(seconds)
2037 END_KV_SERIALIZE_MAP()
2038 };
2039 typedef epee::misc_utils::struct_init<response_t> response;
2040 };
2041
2042 struct COMMAND_RPC_FLUSH_TRANSACTION_POOL
2043 {
2044 struct request_t: public rpc_request_base
2045 {
2046 std::vector<std::string> txids;
2047
2048 BEGIN_KV_SERIALIZE_MAP()
2049 KV_SERIALIZE_PARENT(rpc_request_base)
2050 KV_SERIALIZE(txids)
2051 END_KV_SERIALIZE_MAP()
2052 };
2053 typedef epee::misc_utils::struct_init<request_t> request;
2054
2055 struct response_t: public rpc_response_base
2056 {
2057 BEGIN_KV_SERIALIZE_MAP()
2058 KV_SERIALIZE_PARENT(rpc_response_base)
2059 END_KV_SERIALIZE_MAP()
2060 };
2061 typedef epee::misc_utils::struct_init<response_t> response;
2062 };
2063
2064 struct COMMAND_RPC_GET_OUTPUT_HISTOGRAM
2065 {
2066 struct request_t: public rpc_access_request_base
2067 {
2068 std::vector<uint64_t> amounts;
2069 uint64_t min_count;
2070 uint64_t max_count;
2071 bool unlocked;
2072 uint64_t recent_cutoff;
2073
2074 BEGIN_KV_SERIALIZE_MAP()
2075 KV_SERIALIZE_PARENT(rpc_access_request_base);
2076 KV_SERIALIZE(amounts);
2077 KV_SERIALIZE(min_count);
2078 KV_SERIALIZE(max_count);
2079 KV_SERIALIZE(unlocked);
2080 KV_SERIALIZE(recent_cutoff);
2081 END_KV_SERIALIZE_MAP()
2082 };
2083 typedef epee::misc_utils::struct_init<request_t> request;
2084
2085 struct entry
2086 {
2087 uint64_t amount;
2088 uint64_t total_instances;
2089 uint64_t unlocked_instances;
2090 uint64_t recent_instances;
2091
2092 BEGIN_KV_SERIALIZE_MAP()
2093 KV_SERIALIZE(amount);
2094 KV_SERIALIZE(total_instances);
2095 KV_SERIALIZE(unlocked_instances);
2096 KV_SERIALIZE(recent_instances);
2097 END_KV_SERIALIZE_MAP()
2098
2099 entry(uint64_t amount, uint64_t total_instances, uint64_t unlocked_instances, uint64_t recent_instances):
2100 amount(amount), total_instances(total_instances), unlocked_instances(unlocked_instances), recent_instances(recent_instances) {}
2101 entry() {}
2102 };
2103
2104 struct response_t: public rpc_access_response_base
2105 {
2106 std::vector<entry> histogram;
2107
2108 BEGIN_KV_SERIALIZE_MAP()
2109 KV_SERIALIZE_PARENT(rpc_access_response_base)
2110 KV_SERIALIZE(histogram)
2111 END_KV_SERIALIZE_MAP()
2112 };
2113 typedef epee::misc_utils::struct_init<response_t> response;
2114 };
2115
2116 struct COMMAND_RPC_GET_VERSION
2117 {
2118 struct request_t: public rpc_request_base
2119 {
2120 BEGIN_KV_SERIALIZE_MAP()
2121 KV_SERIALIZE_PARENT(rpc_request_base)
2122 END_KV_SERIALIZE_MAP()
2123 };
2124 typedef epee::misc_utils::struct_init<request_t> request;
2125
2126 struct hf_entry
2127 {
2128 uint8_t hf_version;
2129 uint64_t height;
2130
2131 bool operator==(const hf_entry& hfe) const { return hf_version == hfe.hf_version && height == hfe.height; }
2132
2133 BEGIN_KV_SERIALIZE_MAP()
2134 KV_SERIALIZE(hf_version)
2135 KV_SERIALIZE(height)
2136 END_KV_SERIALIZE_MAP()
2137 };
2138
2139 struct response_t: public rpc_response_base
2140 {
2141 uint32_t version;
2142 bool release;
2143 uint64_t current_height;
2144 uint64_t target_height;
2145 std::vector<hf_entry> hard_forks;
2146
2147 BEGIN_KV_SERIALIZE_MAP()
2148 KV_SERIALIZE_PARENT(rpc_response_base)
2149 KV_SERIALIZE(version)
2150 KV_SERIALIZE(release)
2151 KV_SERIALIZE_OPT(current_height, (uint64_t)0)
2152 KV_SERIALIZE_OPT(target_height, (uint64_t)0)
2153 KV_SERIALIZE_OPT(hard_forks, std::vector<hf_entry>())
2154 END_KV_SERIALIZE_MAP()
2155 };
2156 typedef epee::misc_utils::struct_init<response_t> response;
2157 };
2158
2159 struct COMMAND_RPC_GET_COINBASE_TX_SUM
2160 {
2161 struct request_t: public rpc_access_request_base
2162 {
2163 uint64_t height;
2164 uint64_t count;
2165
2166 BEGIN_KV_SERIALIZE_MAP()
2167 KV_SERIALIZE_PARENT(rpc_access_request_base);
2168 KV_SERIALIZE(height);
2169 KV_SERIALIZE(count);
2170 END_KV_SERIALIZE_MAP()
2171 };
2172 typedef epee::misc_utils::struct_init<request_t> request;
2173
2174 struct response_t: public rpc_access_response_base
2175 {
2176 uint64_t emission_amount;
2177 std::string wide_emission_amount;
2178 uint64_t emission_amount_top64;
2179 uint64_t fee_amount;
2180 std::string wide_fee_amount;
2181 uint64_t fee_amount_top64;
2182
2183 BEGIN_KV_SERIALIZE_MAP()
2184 KV_SERIALIZE_PARENT(rpc_access_response_base)
2185 KV_SERIALIZE(emission_amount)
2186 KV_SERIALIZE(wide_emission_amount)
2187 KV_SERIALIZE(emission_amount_top64)
2188 KV_SERIALIZE(fee_amount)
2189 KV_SERIALIZE(wide_fee_amount)
2190 KV_SERIALIZE(fee_amount_top64)
2191 END_KV_SERIALIZE_MAP()
2192 };
2193 typedef epee::misc_utils::struct_init<response_t> response;
2194 };
2195
2196 struct COMMAND_RPC_GET_BASE_FEE_ESTIMATE
2197 {
2198 struct request_t: public rpc_access_request_base
2199 {
2200 uint64_t grace_blocks;
2201
2202 BEGIN_KV_SERIALIZE_MAP()
2203 KV_SERIALIZE_PARENT(rpc_access_request_base)
2204 KV_SERIALIZE(grace_blocks)
2205 END_KV_SERIALIZE_MAP()
2206 };
2207 typedef epee::misc_utils::struct_init<request_t> request;
2208
2209 struct response_t: public rpc_access_response_base
2210 {
2211 uint64_t fee;
2212 uint64_t quantization_mask;
2213 std::vector<uint64_t> fees;
2214
2215 BEGIN_KV_SERIALIZE_MAP()
2216 KV_SERIALIZE_PARENT(rpc_access_response_base)
2217 KV_SERIALIZE(fee)
2218 KV_SERIALIZE_OPT(quantization_mask, (uint64_t)1)
2219 KV_SERIALIZE(fees)
2220 END_KV_SERIALIZE_MAP()
2221 };
2222 typedef epee::misc_utils::struct_init<response_t> response;
2223 };
2224
2225 struct COMMAND_RPC_GET_ALTERNATE_CHAINS
2226 {
2227 struct request_t: public rpc_request_base
2228 {
2229 BEGIN_KV_SERIALIZE_MAP()
2230 KV_SERIALIZE_PARENT(rpc_request_base)
2231 END_KV_SERIALIZE_MAP()
2232 };
2233 typedef epee::misc_utils::struct_init<request_t> request;
2234
2235 struct chain_info
2236 {
2237 std::string block_hash;
2238 uint64_t height;
2239 uint64_t length;
2240 uint64_t difficulty;
2241 std::string wide_difficulty;
2242 uint64_t difficulty_top64;
2243 std::vector<std::string> block_hashes;
2244 std::string main_chain_parent_block;
2245
2246 BEGIN_KV_SERIALIZE_MAP()
2247 KV_SERIALIZE(block_hash)
2248 KV_SERIALIZE(height)
2249 KV_SERIALIZE(length)
2250 KV_SERIALIZE(difficulty)
2251 KV_SERIALIZE(wide_difficulty)
2252 KV_SERIALIZE(difficulty_top64)
2253 KV_SERIALIZE(block_hashes)
2254 KV_SERIALIZE(main_chain_parent_block)
2255 END_KV_SERIALIZE_MAP()
2256 };
2257
2258 struct response_t: public rpc_response_base
2259 {
2260 std::vector<chain_info> chains;
2261
2262 BEGIN_KV_SERIALIZE_MAP()
2263 KV_SERIALIZE_PARENT(rpc_response_base)
2264 KV_SERIALIZE(chains)
2265 END_KV_SERIALIZE_MAP()
2266 };
2267 typedef epee::misc_utils::struct_init<response_t> response;
2268 };
2269
2270 struct COMMAND_RPC_UPDATE
2271 {
2272 struct request_t: public rpc_request_base
2273 {
2274 std::string command;
2275 std::string path;
2276
2277 BEGIN_KV_SERIALIZE_MAP()
2278 KV_SERIALIZE_PARENT(rpc_request_base)
2279 KV_SERIALIZE(command)
2280 KV_SERIALIZE(path)
2281 END_KV_SERIALIZE_MAP()
2282 };
2283 typedef epee::misc_utils::struct_init<request_t> request;
2284
2285 struct response_t: public rpc_response_base
2286 {
2287 bool update;
2288 std::string version;
2289 std::string user_uri;
2290 std::string auto_uri;
2291 std::string hash;
2292 std::string path;
2293
2294 BEGIN_KV_SERIALIZE_MAP()
2295 KV_SERIALIZE_PARENT(rpc_response_base)
2296 KV_SERIALIZE(update)
2297 KV_SERIALIZE(version)
2298 KV_SERIALIZE(user_uri)
2299 KV_SERIALIZE(auto_uri)
2300 KV_SERIALIZE(hash)
2301 KV_SERIALIZE(path)
2302 END_KV_SERIALIZE_MAP()
2303 };
2304 typedef epee::misc_utils::struct_init<response_t> response;
2305 };
2306
2307 struct COMMAND_RPC_RELAY_TX
2308 {
2309 struct request_t: public rpc_access_request_base
2310 {
2311 std::vector<std::string> txids;
2312
2313 BEGIN_KV_SERIALIZE_MAP()
2314 KV_SERIALIZE_PARENT(rpc_access_request_base)
2315 KV_SERIALIZE(txids)
2316 END_KV_SERIALIZE_MAP()
2317 };
2318 typedef epee::misc_utils::struct_init<request_t> request;
2319
2320 struct response_t: public rpc_access_response_base
2321 {
2322 BEGIN_KV_SERIALIZE_MAP()
2323 KV_SERIALIZE_PARENT(rpc_access_response_base)
2324 END_KV_SERIALIZE_MAP()
2325 };
2326 typedef epee::misc_utils::struct_init<response_t> response;
2327 };
2328
2329 struct COMMAND_RPC_SYNC_INFO
2330 {
2331 struct request_t: public rpc_access_request_base
2332 {
2333 BEGIN_KV_SERIALIZE_MAP()
2334 KV_SERIALIZE_PARENT(rpc_access_request_base)
2335 END_KV_SERIALIZE_MAP()
2336 };
2337 typedef epee::misc_utils::struct_init<request_t> request;
2338
2339 struct peer
2340 {
2341 connection_info info;
2342
2343 BEGIN_KV_SERIALIZE_MAP()
2344 KV_SERIALIZE(info)
2345 END_KV_SERIALIZE_MAP()
2346 };
2347
2348 struct span
2349 {
2350 uint64_t start_block_height;
2351 uint64_t nblocks;
2352 std::string connection_id;
2353 uint32_t rate;
2354 uint32_t speed;
2355 uint64_t size;
2356 std::string remote_address;
2357
2358 BEGIN_KV_SERIALIZE_MAP()
2359 KV_SERIALIZE(start_block_height)
2360 KV_SERIALIZE(nblocks)
2361 KV_SERIALIZE(connection_id)
2362 KV_SERIALIZE(rate)
2363 KV_SERIALIZE(speed)
2364 KV_SERIALIZE(size)
2365 KV_SERIALIZE(remote_address)
2366 END_KV_SERIALIZE_MAP()
2367 };
2368
2369 struct response_t: public rpc_access_response_base
2370 {
2371 uint64_t height;
2372 uint64_t target_height;
2373 uint32_t next_needed_pruning_seed;
2374 std::list<peer> peers;
2375 std::list<span> spans;
2376 std::string overview;
2377
2378 BEGIN_KV_SERIALIZE_MAP()
2379 KV_SERIALIZE_PARENT(rpc_access_response_base)
2380 KV_SERIALIZE(height)
2381 KV_SERIALIZE(target_height)
2382 KV_SERIALIZE(next_needed_pruning_seed)
2383 KV_SERIALIZE(peers)
2384 KV_SERIALIZE(spans)
2385 KV_SERIALIZE(overview)
2386 END_KV_SERIALIZE_MAP()
2387 };
2388 typedef epee::misc_utils::struct_init<response_t> response;
2389 };
2390
2391 struct COMMAND_RPC_GET_OUTPUT_DISTRIBUTION
2392 {
2393 struct request_t: public rpc_access_request_base
2394 {
2395 std::vector<uint64_t> amounts;
2396 uint64_t from_height;
2397 uint64_t to_height;
2398 bool cumulative;
2399 bool binary;
2400 bool compress;
2401
2402 BEGIN_KV_SERIALIZE_MAP()
2403 KV_SERIALIZE_PARENT(rpc_access_request_base)
2404 KV_SERIALIZE(amounts)
2405 KV_SERIALIZE_OPT(from_height, (uint64_t)0)
2406 KV_SERIALIZE_OPT(to_height, (uint64_t)0)
2407 KV_SERIALIZE_OPT(cumulative, false)
2408 KV_SERIALIZE_OPT(binary, true)
2409 KV_SERIALIZE_OPT(compress, false)
2410 END_KV_SERIALIZE_MAP()
2411 };
2412 typedef epee::misc_utils::struct_init<request_t> request;
2413
2414 struct distribution
2415 {
2416 rpc::output_distribution_data data;
2417 uint64_t amount;
2418 std::string compressed_data;
2419 bool binary;
2420 bool compress;
2421
2422 BEGIN_KV_SERIALIZE_MAP()
2423 KV_SERIALIZE(amount)
2424 KV_SERIALIZE_N(data.start_height, "start_height")
2425 KV_SERIALIZE(binary)
2426 KV_SERIALIZE(compress)
2427 if (this_ref.binary)
2428 {
2429 if (is_store)
2430 {
2431 if (this_ref.compress)
2432 {
2433 const_cast<std::string&>(this_ref.compressed_data) = compress_integer_array(this_ref.data.distribution);
2434 KV_SERIALIZE(compressed_data)
2435 }
2436 else
2437 KV_SERIALIZE_CONTAINER_POD_AS_BLOB_N(data.distribution, "distribution")
2438 }
2439 else
2440 {
2441 if (this_ref.compress)
2442 {
2443 KV_SERIALIZE(compressed_data)
2444 const_cast<std::vector<uint64_t>&>(this_ref.data.distribution) = decompress_integer_array<uint64_t>(this_ref.compressed_data);
2445 }
2446 else
2447 KV_SERIALIZE_CONTAINER_POD_AS_BLOB_N(data.distribution, "distribution")
2448 }
2449 }
2450 else
2451 KV_SERIALIZE_N(data.distribution, "distribution")
2452 KV_SERIALIZE_N(data.base, "base")
2453 END_KV_SERIALIZE_MAP()
2454 };
2455
2456 struct response_t: public rpc_access_response_base
2457 {
2458 std::vector<distribution> distributions;
2459
2460 BEGIN_KV_SERIALIZE_MAP()
2461 KV_SERIALIZE_PARENT(rpc_access_response_base)
2462 KV_SERIALIZE(distributions)
2463 END_KV_SERIALIZE_MAP()
2464 };
2465 typedef epee::misc_utils::struct_init<response_t> response;
2466 };
2467
2468 struct COMMAND_RPC_ACCESS_INFO
2469 {
2470 struct request_t: public rpc_access_request_base
2471 {
2472 BEGIN_KV_SERIALIZE_MAP()
2473 KV_SERIALIZE_PARENT(rpc_access_request_base)
2474 END_KV_SERIALIZE_MAP()
2475 };
2476 typedef epee::misc_utils::struct_init<request_t> request;
2477
2478 struct response_t: public rpc_access_response_base
2479 {
2480 std::string hashing_blob;
2481 uint64_t seed_height;
2482 std::string seed_hash;
2483 std::string next_seed_hash;
2484 uint32_t cookie;
2485 uint64_t diff;
2486 uint64_t credits_per_hash_found;
2487 uint64_t height;
2488
2489 BEGIN_KV_SERIALIZE_MAP()
2490 KV_SERIALIZE_PARENT(rpc_access_response_base)
2491 KV_SERIALIZE(hashing_blob)
2492 KV_SERIALIZE(seed_height)
2493 KV_SERIALIZE(seed_hash)
2494 KV_SERIALIZE(next_seed_hash)
2495 KV_SERIALIZE(cookie)
2496 KV_SERIALIZE(diff)
2497 KV_SERIALIZE(credits_per_hash_found)
2498 KV_SERIALIZE(height)
2499 END_KV_SERIALIZE_MAP()
2500 };
2501 typedef epee::misc_utils::struct_init<response_t> response;
2502 };
2503
2504 struct COMMAND_RPC_ACCESS_SUBMIT_NONCE
2505 {
2506 struct request_t: public rpc_access_request_base
2507 {
2508 uint32_t nonce;
2509 uint32_t cookie;
2510
2511 BEGIN_KV_SERIALIZE_MAP()
2512 KV_SERIALIZE_PARENT(rpc_access_request_base)
2513 KV_SERIALIZE(nonce)
2514 KV_SERIALIZE(cookie)
2515 END_KV_SERIALIZE_MAP()
2516 };
2517 typedef epee::misc_utils::struct_init<request_t> request;
2518
2519 struct response_t: public rpc_access_response_base
2520 {
2521 BEGIN_KV_SERIALIZE_MAP()
2522 KV_SERIALIZE_PARENT(rpc_access_response_base)
2523 END_KV_SERIALIZE_MAP()
2524 };
2525 typedef epee::misc_utils::struct_init<response_t> response;
2526 };
2527
2528 struct COMMAND_RPC_ACCESS_PAY
2529 {
2530 struct request_t: public rpc_access_request_base
2531 {
2532 std::string paying_for;
2533 uint64_t payment;
2534
2535 BEGIN_KV_SERIALIZE_MAP()
2536 KV_SERIALIZE_PARENT(rpc_access_request_base)
2537 KV_SERIALIZE(paying_for)
2538 KV_SERIALIZE(payment)
2539 END_KV_SERIALIZE_MAP()
2540 };
2541 typedef epee::misc_utils::struct_init<request_t> request;
2542
2543 struct response_t: public rpc_access_response_base
2544 {
2545 BEGIN_KV_SERIALIZE_MAP()
2546 KV_SERIALIZE_PARENT(rpc_access_response_base)
2547 END_KV_SERIALIZE_MAP()
2548 };
2549 typedef epee::misc_utils::struct_init<response_t> response;
2550 };
2551
2552 struct COMMAND_RPC_ACCESS_TRACKING
2553 {
2554 struct request_t: public rpc_request_base
2555 {
2556 bool clear;
2557
2558 BEGIN_KV_SERIALIZE_MAP()
2559 KV_SERIALIZE_PARENT(rpc_request_base)
2560 KV_SERIALIZE(clear)
2561 END_KV_SERIALIZE_MAP()
2562 };
2563 typedef epee::misc_utils::struct_init<request_t> request;
2564
2565 struct entry
2566 {
2567 std::string rpc;
2568 uint64_t count;
2569 uint64_t time;
2570 uint64_t credits;
2571
2572 BEGIN_KV_SERIALIZE_MAP()
2573 KV_SERIALIZE(rpc)
2574 KV_SERIALIZE(count)
2575 KV_SERIALIZE(time)
2576 KV_SERIALIZE(credits)
2577 END_KV_SERIALIZE_MAP()
2578 };
2579
2580 struct response_t: public rpc_response_base
2581 {
2582 std::vector<entry> data;
2583
2584 BEGIN_KV_SERIALIZE_MAP()
2585 KV_SERIALIZE_PARENT(rpc_response_base)
2586 KV_SERIALIZE(data)
2587 END_KV_SERIALIZE_MAP()
2588 };
2589 typedef epee::misc_utils::struct_init<response_t> response;
2590 };
2591
2592 struct COMMAND_RPC_ACCESS_DATA
2593 {
2594 struct request_t: public rpc_request_base
2595 {
2596 BEGIN_KV_SERIALIZE_MAP()
2597 KV_SERIALIZE_PARENT(rpc_request_base)
2598 END_KV_SERIALIZE_MAP()
2599 };
2600 typedef epee::misc_utils::struct_init<request_t> request;
2601
2602 struct entry
2603 {
2604 std::string client;
2605 uint64_t balance;
2606 uint64_t last_update_time;
2607 uint64_t credits_total;
2608 uint64_t credits_used;
2609 uint64_t nonces_good;
2610 uint64_t nonces_stale;
2611 uint64_t nonces_bad;
2612 uint64_t nonces_dupe;
2613
2614 BEGIN_KV_SERIALIZE_MAP()
2615 KV_SERIALIZE(client)
2616 KV_SERIALIZE(balance)
2617 KV_SERIALIZE(last_update_time)
2618 KV_SERIALIZE(credits_total)
2619 KV_SERIALIZE(credits_used)
2620 KV_SERIALIZE(nonces_good)
2621 KV_SERIALIZE(nonces_stale)
2622 KV_SERIALIZE(nonces_bad)
2623 KV_SERIALIZE(nonces_dupe)
2624 END_KV_SERIALIZE_MAP()
2625 };
2626
2627 struct response_t: public rpc_response_base
2628 {
2629 std::list<entry> entries;
2630 uint32_t hashrate;
2631
2632 BEGIN_KV_SERIALIZE_MAP()
2633 KV_SERIALIZE_PARENT(rpc_response_base)
2634 KV_SERIALIZE(entries)
2635 KV_SERIALIZE(hashrate)
2636 END_KV_SERIALIZE_MAP()
2637 };
2638 typedef epee::misc_utils::struct_init<response_t> response;
2639 };
2640
2641 struct COMMAND_RPC_ACCESS_ACCOUNT
2642 {
2643 struct request_t: public rpc_request_base
2644 {
2645 std::string client;
2646 int64_t delta_balance;
2647
2648 BEGIN_KV_SERIALIZE_MAP()
2649 KV_SERIALIZE_PARENT(rpc_request_base)
2650 KV_SERIALIZE(client)
2651 KV_SERIALIZE_OPT(delta_balance, (int64_t)0)
2652 END_KV_SERIALIZE_MAP()
2653 };
2654 typedef epee::misc_utils::struct_init<request_t> request;
2655
2656 struct response_t: public rpc_response_base
2657 {
2658 uint64_t credits;
2659
2660 BEGIN_KV_SERIALIZE_MAP()
2661 KV_SERIALIZE_PARENT(rpc_response_base)
2662 KV_SERIALIZE(credits)
2663 END_KV_SERIALIZE_MAP()
2664 };
2665 typedef epee::misc_utils::struct_init<response_t> response;
2666 };
2667
2668 struct COMMAND_RPC_POP_BLOCKS
2669 {
2670 struct request_t: public rpc_request_base
2671 {
2672 uint64_t nblocks;
2673
2674 BEGIN_KV_SERIALIZE_MAP()
2675 KV_SERIALIZE_PARENT(rpc_request_base)
2676 KV_SERIALIZE(nblocks)
2677 END_KV_SERIALIZE_MAP()
2678 };
2679 typedef epee::misc_utils::struct_init<request_t> request;
2680
2681 struct response_t: public rpc_response_base
2682 {
2683 uint64_t height;
2684
2685 BEGIN_KV_SERIALIZE_MAP()
2686 KV_SERIALIZE_PARENT(rpc_response_base)
2687 KV_SERIALIZE(height)
2688 END_KV_SERIALIZE_MAP()
2689 };
2690 typedef epee::misc_utils::struct_init<response_t> response;
2691 };
2692
2693 struct COMMAND_RPC_PRUNE_BLOCKCHAIN
2694 {
2695 struct request_t: public rpc_request_base
2696 {
2697 bool check;
2698
2699 BEGIN_KV_SERIALIZE_MAP()
2700 KV_SERIALIZE_PARENT(rpc_request_base)
2701 KV_SERIALIZE_OPT(check, false)
2702 END_KV_SERIALIZE_MAP()
2703 };
2704 typedef epee::misc_utils::struct_init<request_t> request;
2705
2706 struct response_t: public rpc_response_base
2707 {
2708 bool pruned;
2709 uint32_t pruning_seed;
2710
2711 BEGIN_KV_SERIALIZE_MAP()
2712 KV_SERIALIZE_PARENT(rpc_response_base)
2713 KV_SERIALIZE(pruned)
2714 KV_SERIALIZE(pruning_seed)
2715 END_KV_SERIALIZE_MAP()
2716 };
2717 typedef epee::misc_utils::struct_init<response_t> response;
2718 };
2719
2720 struct COMMAND_RPC_FLUSH_CACHE
2721 {
2722 struct request_t: public rpc_request_base
2723 {
2724 bool bad_txs;
2725 bool bad_blocks;
2726
2727 BEGIN_KV_SERIALIZE_MAP()
2728 KV_SERIALIZE_PARENT(rpc_request_base)
2729 KV_SERIALIZE_OPT(bad_txs, false)
2730 KV_SERIALIZE_OPT(bad_blocks, false)
2731 END_KV_SERIALIZE_MAP()
2732 };
2733 typedef epee::misc_utils::struct_init<request_t> request;
2734
2735 struct response_t: public rpc_response_base
2736 {
2737 BEGIN_KV_SERIALIZE_MAP()
2738 KV_SERIALIZE_PARENT(rpc_response_base)
2739 END_KV_SERIALIZE_MAP()
2740 };
2741 typedef epee::misc_utils::struct_init<response_t> response;
2742 };
2743
2744}
s
#define s(x, c)
Definition: aesb.c:47
prune
static void prune(MDB_env *env0, MDB_env *env1)
Definition: blockchain_prune.cpp:249
fees
static boost::multiprecision::uint128_t fees
Definition: blockchain_stats.cpp:58
outputs
std::tuple< uint64_t, uint64_t, std::vector< tools::wallet2::transfer_details > > outputs
Definition: cold-outputs.cpp:53
cryptonote_basic.h
cryptonote_protocol_defs.h
count
int * count
Definition: gmock_stress_test.cc:176
key
const char * key
Definition: hmac_keccak.cpp:40
client
static epee::net_utils::http::http_simple_client_template< dummy_client > client
Definition: http-client.cpp:62
KV_SERIALIZE_VAL_POD_AS_BLOB
#define KV_SERIALIZE_VAL_POD_AS_BLOB(varialble)
Definition: keyvalue_serialization.h:119
KV_SERIALIZE
#define KV_SERIALIZE(varialble)
Definition: keyvalue_serialization.h:118
KV_SERIALIZE_CONTAINER_POD_AS_BLOB_N
#define KV_SERIALIZE_CONTAINER_POD_AS_BLOB_N(varialble, val_name)
Definition: keyvalue_serialization.h:113
KV_SERIALIZE_OPT
#define KV_SERIALIZE_OPT(variable, default_value)
Definition: keyvalue_serialization.h:123
KV_SERIALIZE_CONTAINER_POD_AS_BLOB
#define KV_SERIALIZE_CONTAINER_POD_AS_BLOB(varialble)
Definition: keyvalue_serialization.h:122
KV_SERIALIZE_PARENT
#define KV_SERIALIZE_PARENT(type)
Definition: keyvalue_serialization.h:81
END_KV_SERIALIZE_MAP
#define END_KV_SERIALIZE_MAP()
Definition: keyvalue_serialization.h:116
BEGIN_KV_SERIALIZE_MAP
#define BEGIN_KV_SERIALIZE_MAP()
Definition: keyvalue_serialization.h:43
KV_SERIALIZE_N
#define KV_SERIALIZE_N(varialble, val_name)
Definition: keyvalue_serialization.h:78
active
epee::byte_slice active
Definition: levin_notify.cpp:255
info
static MDB_envinfo info
Definition: mdb_load.c:37
version
static int version
Definition: mdb_load.c:29
address
uint32_t address
Definition: getifaddr.c:269
bans
Definition: bans.py:1
base
Definition: base.py:1
block_weight
Definition: block_weight.py:1
blocks
Definition: blocks.cpp:13
check
Definition: check.py:1
console.t
urllib t
Definition: console.py:33
crypto::public_key
POD_CLASS public_key
Definition: crypto.h:64
crypto::hash
POD_CLASS hash
Definition: hash.h:48
cryptonote
Holds cryptonote related classes and helpers.
Definition: blockchain_db.cpp:45
cryptonote::blobdata
std::string blobdata
Definition: blobdatatype.h:39
epee
TODO: (mj-xmr) This will be reduced in an another PR.
Definition: byte_slice.h:40
speed
Definition: speed.py:1
std
Definition: enums.h:68
tools::write_varint
std::enable_if< std::is_integral< T >::value &&std::is_unsigned< T >::value, void >::type write_varint(OutputIt &&dest, T i)
writes a varint to a stream.
Definition: varint.h:69
wide_difficulty
Definition: wide_difficulty.py:1
id
enum upnpconfigoptions id
Definition: options.c:29
perf_timer.h
rpc_handler.h
if
if(!cryptonote::get_account_address_from_str_or_url(info, cryptonote::TESTNET, "9uVsvEryzpN8WH2t1WWhFFCG5tS8cBNdmJYNRuckLENFimfauV5pZKeS1P2CbxGkSDTUPHXWwiYE5ZGSXDAGbaZgDxobqDN"))
Definition: signature.cpp:53
port
boost::endian::big_uint16_t port
Definition: socks.cpp:59
ip
boost::endian::big_uint32_t ip
Definition: socks.cpp:60
depth
static __thread int depth
Definition: threadpool.cpp:34
true
#define true
Definition: stdbool.h:36
false
#define false
Definition: stdbool.h:37
uint16_t
unsigned short uint16_t
Definition: stdint.h:125
int64_t
signed __int64 int64_t
Definition: stdint.h:135
uint32_t
unsigned int uint32_t
Definition: stdint.h:126
uint8_t
unsigned char uint8_t
Definition: stdint.h:124
uint64_t
unsigned __int64 uint64_t
Definition: stdint.h:136
int8_t
signed char int8_t
Definition: stdint.h:121
string_tools.h
cryptonote::COMMAND_RPC_ACCESS_ACCOUNT::request_t
Definition: core_rpc_server_commands_defs.h:2644
cryptonote::COMMAND_RPC_ACCESS_ACCOUNT::request_t::delta_balance
int64_t delta_balance
Definition: core_rpc_server_commands_defs.h:2646
cryptonote::COMMAND_RPC_ACCESS_ACCOUNT::request_t::client
std::string client
Definition: core_rpc_server_commands_defs.h:2645
cryptonote::COMMAND_RPC_ACCESS_ACCOUNT::response_t
Definition: core_rpc_server_commands_defs.h:2657
cryptonote::COMMAND_RPC_ACCESS_ACCOUNT::response_t::credits
uint64_t credits
Definition: core_rpc_server_commands_defs.h:2658
cryptonote::COMMAND_RPC_ACCESS_ACCOUNT
Definition: core_rpc_server_commands_defs.h:2642
cryptonote::COMMAND_RPC_ACCESS_DATA::entry
Definition: core_rpc_server_commands_defs.h:2603
cryptonote::COMMAND_RPC_ACCESS_DATA::entry::last_update_time
uint64_t last_update_time
Definition: core_rpc_server_commands_defs.h:2606
cryptonote::COMMAND_RPC_ACCESS_DATA::entry::nonces_stale
uint64_t nonces_stale
Definition: core_rpc_server_commands_defs.h:2610
cryptonote::COMMAND_RPC_ACCESS_DATA::entry::client
std::string client
Definition: core_rpc_server_commands_defs.h:2604
cryptonote::COMMAND_RPC_ACCESS_DATA::entry::credits_used
uint64_t credits_used
Definition: core_rpc_server_commands_defs.h:2608
cryptonote::COMMAND_RPC_ACCESS_DATA::entry::credits_total
uint64_t credits_total
Definition: core_rpc_server_commands_defs.h:2607
cryptonote::COMMAND_RPC_ACCESS_DATA::entry::nonces_bad
uint64_t nonces_bad
Definition: core_rpc_server_commands_defs.h:2611
cryptonote::COMMAND_RPC_ACCESS_DATA::entry::balance
uint64_t balance
Definition: core_rpc_server_commands_defs.h:2605
cryptonote::COMMAND_RPC_ACCESS_DATA::entry::nonces_good
uint64_t nonces_good
Definition: core_rpc_server_commands_defs.h:2609
cryptonote::COMMAND_RPC_ACCESS_DATA::entry::nonces_dupe
uint64_t nonces_dupe
Definition: core_rpc_server_commands_defs.h:2612
cryptonote::COMMAND_RPC_ACCESS_DATA::request_t
Definition: core_rpc_server_commands_defs.h:2595
cryptonote::COMMAND_RPC_ACCESS_DATA::response_t
Definition: core_rpc_server_commands_defs.h:2628
cryptonote::COMMAND_RPC_ACCESS_DATA::response_t::hashrate
uint32_t hashrate
Definition: core_rpc_server_commands_defs.h:2630
cryptonote::COMMAND_RPC_ACCESS_DATA::response_t::entries
std::list< entry > entries
Definition: core_rpc_server_commands_defs.h:2629
cryptonote::COMMAND_RPC_ACCESS_DATA
Definition: core_rpc_server_commands_defs.h:2593
cryptonote::COMMAND_RPC_ACCESS_DATA::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:2600
cryptonote::COMMAND_RPC_ACCESS_INFO::request_t
Definition: core_rpc_server_commands_defs.h:2471
cryptonote::COMMAND_RPC_ACCESS_INFO::response_t
Definition: core_rpc_server_commands_defs.h:2479
cryptonote::COMMAND_RPC_ACCESS_INFO::response_t::height
uint64_t height
Definition: core_rpc_server_commands_defs.h:2487
cryptonote::COMMAND_RPC_ACCESS_INFO::response_t::next_seed_hash
std::string next_seed_hash
Definition: core_rpc_server_commands_defs.h:2483
cryptonote::COMMAND_RPC_ACCESS_INFO::response_t::cookie
uint32_t cookie
Definition: core_rpc_server_commands_defs.h:2484
cryptonote::COMMAND_RPC_ACCESS_INFO::response_t::hashing_blob
std::string hashing_blob
Definition: core_rpc_server_commands_defs.h:2480
cryptonote::COMMAND_RPC_ACCESS_INFO::response_t::seed_height
uint64_t seed_height
Definition: core_rpc_server_commands_defs.h:2481
cryptonote::COMMAND_RPC_ACCESS_INFO::response_t::credits_per_hash_found
uint64_t credits_per_hash_found
Definition: core_rpc_server_commands_defs.h:2486
cryptonote::COMMAND_RPC_ACCESS_INFO::response_t::seed_hash
std::string seed_hash
Definition: core_rpc_server_commands_defs.h:2482
cryptonote::COMMAND_RPC_ACCESS_INFO::response_t::diff
uint64_t diff
Definition: core_rpc_server_commands_defs.h:2485
cryptonote::COMMAND_RPC_ACCESS_INFO
Definition: core_rpc_server_commands_defs.h:2469
cryptonote::COMMAND_RPC_ACCESS_INFO::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:2476
cryptonote::COMMAND_RPC_ACCESS_PAY::request_t
Definition: core_rpc_server_commands_defs.h:2531
cryptonote::COMMAND_RPC_ACCESS_PAY::request_t::paying_for
std::string paying_for
Definition: core_rpc_server_commands_defs.h:2532
cryptonote::COMMAND_RPC_ACCESS_PAY::request_t::payment
uint64_t payment
Definition: core_rpc_server_commands_defs.h:2533
cryptonote::COMMAND_RPC_ACCESS_PAY::response_t
Definition: core_rpc_server_commands_defs.h:2544
cryptonote::COMMAND_RPC_ACCESS_PAY
Definition: core_rpc_server_commands_defs.h:2529
cryptonote::COMMAND_RPC_ACCESS_PAY::response
epee::misc_utils::struct_init< response_t > response
Definition: core_rpc_server_commands_defs.h:2549
cryptonote::COMMAND_RPC_ACCESS_SUBMIT_NONCE::request_t
Definition: core_rpc_server_commands_defs.h:2507
cryptonote::COMMAND_RPC_ACCESS_SUBMIT_NONCE::request_t::nonce
uint32_t nonce
Definition: core_rpc_server_commands_defs.h:2508
cryptonote::COMMAND_RPC_ACCESS_SUBMIT_NONCE::request_t::cookie
uint32_t cookie
Definition: core_rpc_server_commands_defs.h:2509
cryptonote::COMMAND_RPC_ACCESS_SUBMIT_NONCE::response_t
Definition: core_rpc_server_commands_defs.h:2520
cryptonote::COMMAND_RPC_ACCESS_SUBMIT_NONCE
Definition: core_rpc_server_commands_defs.h:2505
cryptonote::COMMAND_RPC_ACCESS_SUBMIT_NONCE::response
epee::misc_utils::struct_init< response_t > response
Definition: core_rpc_server_commands_defs.h:2525
cryptonote::COMMAND_RPC_ACCESS_TRACKING::entry
Definition: core_rpc_server_commands_defs.h:2566
cryptonote::COMMAND_RPC_ACCESS_TRACKING::entry::credits
uint64_t credits
Definition: core_rpc_server_commands_defs.h:2570
cryptonote::COMMAND_RPC_ACCESS_TRACKING::entry::time
uint64_t time
Definition: core_rpc_server_commands_defs.h:2569
cryptonote::COMMAND_RPC_ACCESS_TRACKING::entry::rpc
std::string rpc
Definition: core_rpc_server_commands_defs.h:2567
cryptonote::COMMAND_RPC_ACCESS_TRACKING::entry::count
uint64_t count
Definition: core_rpc_server_commands_defs.h:2568
cryptonote::COMMAND_RPC_ACCESS_TRACKING::request_t
Definition: core_rpc_server_commands_defs.h:2555
cryptonote::COMMAND_RPC_ACCESS_TRACKING::request_t::clear
bool clear
Definition: core_rpc_server_commands_defs.h:2556
cryptonote::COMMAND_RPC_ACCESS_TRACKING::response_t
Definition: core_rpc_server_commands_defs.h:2581
cryptonote::COMMAND_RPC_ACCESS_TRACKING::response_t::data
std::vector< entry > data
Definition: core_rpc_server_commands_defs.h:2582
cryptonote::COMMAND_RPC_ACCESS_TRACKING
Definition: core_rpc_server_commands_defs.h:2553
cryptonote::COMMAND_RPC_ADD_AUX_POW::aux_pow_t
Definition: core_rpc_server_commands_defs.h:1020
cryptonote::COMMAND_RPC_ADD_AUX_POW::aux_pow_t::hash
std::string hash
Definition: core_rpc_server_commands_defs.h:1022
cryptonote::COMMAND_RPC_ADD_AUX_POW::aux_pow_t::id
std::string id
Definition: core_rpc_server_commands_defs.h:1021
cryptonote::COMMAND_RPC_ADD_AUX_POW::request_t
Definition: core_rpc_server_commands_defs.h:1031
cryptonote::COMMAND_RPC_ADD_AUX_POW::request_t::blocktemplate_blob
blobdata blocktemplate_blob
Definition: core_rpc_server_commands_defs.h:1032
cryptonote::COMMAND_RPC_ADD_AUX_POW::request_t::aux_pow
std::vector< aux_pow_t > aux_pow
Definition: core_rpc_server_commands_defs.h:1033
cryptonote::COMMAND_RPC_ADD_AUX_POW::response_t
Definition: core_rpc_server_commands_defs.h:1044
cryptonote::COMMAND_RPC_ADD_AUX_POW::response_t::merkle_root
std::string merkle_root
Definition: core_rpc_server_commands_defs.h:1047
cryptonote::COMMAND_RPC_ADD_AUX_POW::response_t::merkle_tree_depth
uint32_t merkle_tree_depth
Definition: core_rpc_server_commands_defs.h:1048
cryptonote::COMMAND_RPC_ADD_AUX_POW::response_t::aux_pow
std::vector< aux_pow_t > aux_pow
Definition: core_rpc_server_commands_defs.h:1049
cryptonote::COMMAND_RPC_ADD_AUX_POW::response_t::blockhashing_blob
blobdata blockhashing_blob
Definition: core_rpc_server_commands_defs.h:1046
cryptonote::COMMAND_RPC_ADD_AUX_POW::response_t::blocktemplate_blob
blobdata blocktemplate_blob
Definition: core_rpc_server_commands_defs.h:1045
cryptonote::COMMAND_RPC_ADD_AUX_POW
Definition: core_rpc_server_commands_defs.h:1018
cryptonote::COMMAND_RPC_BANNED::request_t
Definition: core_rpc_server_commands_defs.h:2018
cryptonote::COMMAND_RPC_BANNED::request_t::address
std::string address
Definition: core_rpc_server_commands_defs.h:2019
cryptonote::COMMAND_RPC_BANNED::response_t
Definition: core_rpc_server_commands_defs.h:2028
cryptonote::COMMAND_RPC_BANNED::response_t::seconds
uint32_t seconds
Definition: core_rpc_server_commands_defs.h:2031
cryptonote::COMMAND_RPC_BANNED::response_t::status
std::string status
Definition: core_rpc_server_commands_defs.h:2029
cryptonote::COMMAND_RPC_BANNED::response_t::banned
bool banned
Definition: core_rpc_server_commands_defs.h:2030
cryptonote::COMMAND_RPC_BANNED
Definition: core_rpc_server_commands_defs.h:2016
cryptonote::COMMAND_RPC_CALCPOW::request_t
Definition: core_rpc_server_commands_defs.h:998
cryptonote::COMMAND_RPC_CALCPOW::request_t::major_version
uint8_t major_version
Definition: core_rpc_server_commands_defs.h:999
cryptonote::COMMAND_RPC_CALCPOW::request_t::seed_hash
std::string seed_hash
Definition: core_rpc_server_commands_defs.h:1002
cryptonote::COMMAND_RPC_CALCPOW::request_t::height
uint64_t height
Definition: core_rpc_server_commands_defs.h:1000
cryptonote::COMMAND_RPC_CALCPOW::request_t::block_blob
blobdata block_blob
Definition: core_rpc_server_commands_defs.h:1001
cryptonote::COMMAND_RPC_CALCPOW
Definition: core_rpc_server_commands_defs.h:996
cryptonote::COMMAND_RPC_CALCPOW::response
std::string response
Definition: core_rpc_server_commands_defs.h:1014
cryptonote::COMMAND_RPC_FAST_EXIT::request_t
Definition: core_rpc_server_commands_defs.h:1782
cryptonote::COMMAND_RPC_FAST_EXIT::response_t
Definition: core_rpc_server_commands_defs.h:1790
cryptonote::COMMAND_RPC_FAST_EXIT
Definition: core_rpc_server_commands_defs.h:1780
cryptonote::COMMAND_RPC_FAST_EXIT::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:1787
cryptonote::COMMAND_RPC_FAST_EXIT::response
epee::misc_utils::struct_init< response_t > response
Definition: core_rpc_server_commands_defs.h:1795
cryptonote::COMMAND_RPC_FLUSH_CACHE::request_t
Definition: core_rpc_server_commands_defs.h:2723
cryptonote::COMMAND_RPC_FLUSH_CACHE::request_t::bad_txs
bool bad_txs
Definition: core_rpc_server_commands_defs.h:2724
cryptonote::COMMAND_RPC_FLUSH_CACHE::request_t::bad_blocks
bool bad_blocks
Definition: core_rpc_server_commands_defs.h:2725
cryptonote::COMMAND_RPC_FLUSH_CACHE::response_t
Definition: core_rpc_server_commands_defs.h:2736
cryptonote::COMMAND_RPC_FLUSH_CACHE
Definition: core_rpc_server_commands_defs.h:2721
cryptonote::COMMAND_RPC_FLUSH_CACHE::response
epee::misc_utils::struct_init< response_t > response
Definition: core_rpc_server_commands_defs.h:2741
cryptonote::COMMAND_RPC_FLUSH_TRANSACTION_POOL::request_t
Definition: core_rpc_server_commands_defs.h:2045
cryptonote::COMMAND_RPC_FLUSH_TRANSACTION_POOL::request_t::txids
std::vector< std::string > txids
Definition: core_rpc_server_commands_defs.h:2046
cryptonote::COMMAND_RPC_FLUSH_TRANSACTION_POOL::response_t
Definition: core_rpc_server_commands_defs.h:2056
cryptonote::COMMAND_RPC_FLUSH_TRANSACTION_POOL
Definition: core_rpc_server_commands_defs.h:2043
cryptonote::COMMAND_RPC_FLUSH_TRANSACTION_POOL::response
epee::misc_utils::struct_init< response_t > response
Definition: core_rpc_server_commands_defs.h:2061
cryptonote::COMMAND_RPC_GENERATEBLOCKS::request_t
Definition: core_rpc_server_commands_defs.h:1079
cryptonote::COMMAND_RPC_GENERATEBLOCKS::request_t::amount_of_blocks
uint64_t amount_of_blocks
Definition: core_rpc_server_commands_defs.h:1080
cryptonote::COMMAND_RPC_GENERATEBLOCKS::request_t::wallet_address
std::string wallet_address
Definition: core_rpc_server_commands_defs.h:1081
cryptonote::COMMAND_RPC_GENERATEBLOCKS::request_t::prev_block
std::string prev_block
Definition: core_rpc_server_commands_defs.h:1082
cryptonote::COMMAND_RPC_GENERATEBLOCKS::request_t::starting_nonce
uint32_t starting_nonce
Definition: core_rpc_server_commands_defs.h:1083
cryptonote::COMMAND_RPC_GENERATEBLOCKS::response_t
Definition: core_rpc_server_commands_defs.h:1096
cryptonote::COMMAND_RPC_GENERATEBLOCKS::response_t::height
uint64_t height
Definition: core_rpc_server_commands_defs.h:1097
cryptonote::COMMAND_RPC_GENERATEBLOCKS::response_t::blocks
std::vector< std::string > blocks
Definition: core_rpc_server_commands_defs.h:1098
cryptonote::COMMAND_RPC_GENERATEBLOCKS
Definition: core_rpc_server_commands_defs.h:1077
cryptonote::COMMAND_RPC_GETBANS::ban
Definition: core_rpc_server_commands_defs.h:1946
cryptonote::COMMAND_RPC_GETBANS::ban::seconds
uint32_t seconds
Definition: core_rpc_server_commands_defs.h:1949
cryptonote::COMMAND_RPC_GETBANS::ban::ip
uint32_t ip
Definition: core_rpc_server_commands_defs.h:1948
cryptonote::COMMAND_RPC_GETBANS::ban::host
std::string host
Definition: core_rpc_server_commands_defs.h:1947
cryptonote::COMMAND_RPC_GETBANS::request_t
Definition: core_rpc_server_commands_defs.h:1959
cryptonote::COMMAND_RPC_GETBANS::response_t
Definition: core_rpc_server_commands_defs.h:1967
cryptonote::COMMAND_RPC_GETBANS::response_t::bans
std::vector< ban > bans
Definition: core_rpc_server_commands_defs.h:1968
cryptonote::COMMAND_RPC_GETBANS
Definition: core_rpc_server_commands_defs.h:1944
cryptonote::COMMAND_RPC_GETBANS::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:1964
cryptonote::COMMAND_RPC_GETBLOCKCOUNT::response_t
Definition: core_rpc_server_commands_defs.h:873
cryptonote::COMMAND_RPC_GETBLOCKCOUNT::response_t::count
uint64_t count
Definition: core_rpc_server_commands_defs.h:874
cryptonote::COMMAND_RPC_GETBLOCKCOUNT
Definition: core_rpc_server_commands_defs.h:869
cryptonote::COMMAND_RPC_GETBLOCKCOUNT::request
std::list< std::string > request
Definition: core_rpc_server_commands_defs.h:870
cryptonote::COMMAND_RPC_GETBLOCKHASH
Definition: core_rpc_server_commands_defs.h:885
cryptonote::COMMAND_RPC_GETBLOCKHASH::request
std::vector< uint64_t > request
Definition: core_rpc_server_commands_defs.h:886
cryptonote::COMMAND_RPC_GETBLOCKHASH::response
std::string response
Definition: core_rpc_server_commands_defs.h:888
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::request_t
Definition: core_rpc_server_commands_defs.h:895
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::request_t::wallet_address
std::string wallet_address
Definition: core_rpc_server_commands_defs.h:897
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::request_t::reserve_size
uint64_t reserve_size
Definition: core_rpc_server_commands_defs.h:896
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::request_t::prev_block
std::string prev_block
Definition: core_rpc_server_commands_defs.h:898
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::request_t::extra_nonce
std::string extra_nonce
Definition: core_rpc_server_commands_defs.h:899
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::response_t
Definition: core_rpc_server_commands_defs.h:912
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::response_t::prev_hash
std::string prev_hash
Definition: core_rpc_server_commands_defs.h:919
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::response_t::difficulty
uint64_t difficulty
Definition: core_rpc_server_commands_defs.h:913
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::response_t::height
uint64_t height
Definition: core_rpc_server_commands_defs.h:916
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::response_t::expected_reward
uint64_t expected_reward
Definition: core_rpc_server_commands_defs.h:918
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::response_t::blocktemplate_blob
blobdata blocktemplate_blob
Definition: core_rpc_server_commands_defs.h:923
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::response_t::difficulty_top64
uint64_t difficulty_top64
Definition: core_rpc_server_commands_defs.h:915
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::response_t::seed_hash
std::string seed_hash
Definition: core_rpc_server_commands_defs.h:921
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::response_t::next_seed_hash
std::string next_seed_hash
Definition: core_rpc_server_commands_defs.h:922
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::response_t::blockhashing_blob
blobdata blockhashing_blob
Definition: core_rpc_server_commands_defs.h:924
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::response_t::seed_height
uint64_t seed_height
Definition: core_rpc_server_commands_defs.h:920
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::response_t::wide_difficulty
std::string wide_difficulty
Definition: core_rpc_server_commands_defs.h:914
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE::response_t::reserved_offset
uint64_t reserved_offset
Definition: core_rpc_server_commands_defs.h:917
cryptonote::COMMAND_RPC_GETBLOCKTEMPLATE
Definition: core_rpc_server_commands_defs.h:893
cryptonote::COMMAND_RPC_GETMINERDATA::request_t
Definition: core_rpc_server_commands_defs.h:948
cryptonote::COMMAND_RPC_GETMINERDATA::response_t::tx_backlog_entry
Definition: core_rpc_server_commands_defs.h:966
cryptonote::COMMAND_RPC_GETMINERDATA::response_t::tx_backlog_entry::weight
uint64_t weight
Definition: core_rpc_server_commands_defs.h:968
cryptonote::COMMAND_RPC_GETMINERDATA::response_t::tx_backlog_entry::id
std::string id
Definition: core_rpc_server_commands_defs.h:967
cryptonote::COMMAND_RPC_GETMINERDATA::response_t::tx_backlog_entry::fee
uint64_t fee
Definition: core_rpc_server_commands_defs.h:969
cryptonote::COMMAND_RPC_GETMINERDATA::response_t
Definition: core_rpc_server_commands_defs.h:956
cryptonote::COMMAND_RPC_GETMINERDATA::response_t::median_weight
uint64_t median_weight
Definition: core_rpc_server_commands_defs.h:962
cryptonote::COMMAND_RPC_GETMINERDATA::response_t::difficulty
std::string difficulty
Definition: core_rpc_server_commands_defs.h:961
cryptonote::COMMAND_RPC_GETMINERDATA::response_t::prev_id
std::string prev_id
Definition: core_rpc_server_commands_defs.h:959
cryptonote::COMMAND_RPC_GETMINERDATA::response_t::height
uint64_t height
Definition: core_rpc_server_commands_defs.h:958
cryptonote::COMMAND_RPC_GETMINERDATA::response_t::major_version
uint8_t major_version
Definition: core_rpc_server_commands_defs.h:957
cryptonote::COMMAND_RPC_GETMINERDATA::response_t::seed_hash
std::string seed_hash
Definition: core_rpc_server_commands_defs.h:960
cryptonote::COMMAND_RPC_GETMINERDATA::response_t::already_generated_coins
uint64_t already_generated_coins
Definition: core_rpc_server_commands_defs.h:963
cryptonote::COMMAND_RPC_GETMINERDATA
Definition: core_rpc_server_commands_defs.h:946
cryptonote::COMMAND_RPC_GETMINERDATA::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:953
cryptonote::COMMAND_RPC_GET_ALTERNATE_CHAINS::chain_info
Definition: core_rpc_server_commands_defs.h:2236
cryptonote::COMMAND_RPC_GET_ALTERNATE_CHAINS::chain_info::difficulty_top64
uint64_t difficulty_top64
Definition: core_rpc_server_commands_defs.h:2242
cryptonote::COMMAND_RPC_GET_ALTERNATE_CHAINS::chain_info::length
uint64_t length
Definition: core_rpc_server_commands_defs.h:2239
cryptonote::COMMAND_RPC_GET_ALTERNATE_CHAINS::chain_info::height
uint64_t height
Definition: core_rpc_server_commands_defs.h:2238
cryptonote::COMMAND_RPC_GET_ALTERNATE_CHAINS::chain_info::block_hashes
std::vector< std::string > block_hashes
Definition: core_rpc_server_commands_defs.h:2243
cryptonote::COMMAND_RPC_GET_ALTERNATE_CHAINS::chain_info::block_hash
std::string block_hash
Definition: core_rpc_server_commands_defs.h:2237
cryptonote::COMMAND_RPC_GET_ALTERNATE_CHAINS::chain_info::main_chain_parent_block
std::string main_chain_parent_block
Definition: core_rpc_server_commands_defs.h:2244
cryptonote::COMMAND_RPC_GET_ALTERNATE_CHAINS::chain_info::difficulty
uint64_t difficulty
Definition: core_rpc_server_commands_defs.h:2240
cryptonote::COMMAND_RPC_GET_ALTERNATE_CHAINS::chain_info::wide_difficulty
std::string wide_difficulty
Definition: core_rpc_server_commands_defs.h:2241
cryptonote::COMMAND_RPC_GET_ALTERNATE_CHAINS::request_t
Definition: core_rpc_server_commands_defs.h:2228
cryptonote::COMMAND_RPC_GET_ALTERNATE_CHAINS::response_t
Definition: core_rpc_server_commands_defs.h:2259
cryptonote::COMMAND_RPC_GET_ALTERNATE_CHAINS::response_t::chains
std::vector< chain_info > chains
Definition: core_rpc_server_commands_defs.h:2260
cryptonote::COMMAND_RPC_GET_ALTERNATE_CHAINS
Definition: core_rpc_server_commands_defs.h:2226
cryptonote::COMMAND_RPC_GET_ALTERNATE_CHAINS::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:2233
cryptonote::COMMAND_RPC_GET_ALT_BLOCKS_HASHES::request_t
Definition: core_rpc_server_commands_defs.h:244
cryptonote::COMMAND_RPC_GET_ALT_BLOCKS_HASHES::response_t
Definition: core_rpc_server_commands_defs.h:252
cryptonote::COMMAND_RPC_GET_ALT_BLOCKS_HASHES::response_t::blks_hashes
std::vector< std::string > blks_hashes
Definition: core_rpc_server_commands_defs.h:253
cryptonote::COMMAND_RPC_GET_ALT_BLOCKS_HASHES
Definition: core_rpc_server_commands_defs.h:242
cryptonote::COMMAND_RPC_GET_ALT_BLOCKS_HASHES::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:249
cryptonote::COMMAND_RPC_GET_BASE_FEE_ESTIMATE::request_t
Definition: core_rpc_server_commands_defs.h:2199
cryptonote::COMMAND_RPC_GET_BASE_FEE_ESTIMATE::request_t::grace_blocks
uint64_t grace_blocks
Definition: core_rpc_server_commands_defs.h:2200
cryptonote::COMMAND_RPC_GET_BASE_FEE_ESTIMATE::response_t
Definition: core_rpc_server_commands_defs.h:2210
cryptonote::COMMAND_RPC_GET_BASE_FEE_ESTIMATE::response_t::fees
std::vector< uint64_t > fees
Definition: core_rpc_server_commands_defs.h:2213
cryptonote::COMMAND_RPC_GET_BASE_FEE_ESTIMATE::response_t::quantization_mask
uint64_t quantization_mask
Definition: core_rpc_server_commands_defs.h:2212
cryptonote::COMMAND_RPC_GET_BASE_FEE_ESTIMATE::response_t::fee
uint64_t fee
Definition: core_rpc_server_commands_defs.h:2211
cryptonote::COMMAND_RPC_GET_BASE_FEE_ESTIMATE
Definition: core_rpc_server_commands_defs.h:2197
cryptonote::COMMAND_RPC_GET_BLOCKS_BY_HEIGHT::request_t
Definition: core_rpc_server_commands_defs.h:220
cryptonote::COMMAND_RPC_GET_BLOCKS_BY_HEIGHT::request_t::heights
std::vector< uint64_t > heights
Definition: core_rpc_server_commands_defs.h:221
cryptonote::COMMAND_RPC_GET_BLOCKS_BY_HEIGHT::response_t
Definition: core_rpc_server_commands_defs.h:230
cryptonote::COMMAND_RPC_GET_BLOCKS_BY_HEIGHT::response_t::blocks
std::vector< block_complete_entry > blocks
Definition: core_rpc_server_commands_defs.h:231
cryptonote::COMMAND_RPC_GET_BLOCKS_BY_HEIGHT
Definition: core_rpc_server_commands_defs.h:218
cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::block_output_indices
Definition: core_rpc_server_commands_defs.h:191
cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::block_output_indices::indices
std::vector< tx_output_indices > indices
Definition: core_rpc_server_commands_defs.h:192
cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::request_t
Definition: core_rpc_server_commands_defs.h:166
cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::request_t::prune
bool prune
Definition: core_rpc_server_commands_defs.h:169
cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::request_t::start_height
uint64_t start_height
Definition: core_rpc_server_commands_defs.h:168
cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::request_t::block_ids
std::list< crypto::hash > block_ids
Definition: core_rpc_server_commands_defs.h:167
cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::request_t::no_miner_tx
bool no_miner_tx
Definition: core_rpc_server_commands_defs.h:170
cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::response_t
Definition: core_rpc_server_commands_defs.h:200
cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::response_t::output_indices
std::vector< block_output_indices > output_indices
Definition: core_rpc_server_commands_defs.h:204
cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::response_t::start_height
uint64_t start_height
Definition: core_rpc_server_commands_defs.h:202
cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::response_t::current_height
uint64_t current_height
Definition: core_rpc_server_commands_defs.h:203
cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::response_t::blocks
std::vector< block_complete_entry > blocks
Definition: core_rpc_server_commands_defs.h:201
cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::tx_output_indices
Definition: core_rpc_server_commands_defs.h:182
cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::tx_output_indices::indices
std::vector< uint64_t > indices
Definition: core_rpc_server_commands_defs.h:183
cryptonote::COMMAND_RPC_GET_BLOCKS_FAST
Definition: core_rpc_server_commands_defs.h:163
cryptonote::COMMAND_RPC_GET_BLOCK::request_t
Definition: core_rpc_server_commands_defs.h:1247
cryptonote::COMMAND_RPC_GET_BLOCK::request_t::fill_pow_hash
bool fill_pow_hash
Definition: core_rpc_server_commands_defs.h:1250
cryptonote::COMMAND_RPC_GET_BLOCK::request_t::height
uint64_t height
Definition: core_rpc_server_commands_defs.h:1249
cryptonote::COMMAND_RPC_GET_BLOCK::request_t::hash
std::string hash
Definition: core_rpc_server_commands_defs.h:1248
cryptonote::COMMAND_RPC_GET_BLOCK::response_t
Definition: core_rpc_server_commands_defs.h:1262
cryptonote::COMMAND_RPC_GET_BLOCK::response_t::tx_hashes
std::vector< std::string > tx_hashes
Definition: core_rpc_server_commands_defs.h:1265
cryptonote::COMMAND_RPC_GET_BLOCK::response_t::blob
std::string blob
Definition: core_rpc_server_commands_defs.h:1266
cryptonote::COMMAND_RPC_GET_BLOCK::response_t::block_header
block_header_response block_header
Definition: core_rpc_server_commands_defs.h:1263
cryptonote::COMMAND_RPC_GET_BLOCK::response_t::miner_tx_hash
std::string miner_tx_hash
Definition: core_rpc_server_commands_defs.h:1264
cryptonote::COMMAND_RPC_GET_BLOCK::response_t::json
std::string json
Definition: core_rpc_server_commands_defs.h:1267
cryptonote::COMMAND_RPC_GET_BLOCK_HEADERS_RANGE::request_t
Definition: core_rpc_server_commands_defs.h:1705
cryptonote::COMMAND_RPC_GET_BLOCK_HEADERS_RANGE::request_t::end_height
uint64_t end_height
Definition: core_rpc_server_commands_defs.h:1707
cryptonote::COMMAND_RPC_GET_BLOCK_HEADERS_RANGE::request_t::start_height
uint64_t start_height
Definition: core_rpc_server_commands_defs.h:1706
cryptonote::COMMAND_RPC_GET_BLOCK_HEADERS_RANGE::request_t::fill_pow_hash
bool fill_pow_hash
Definition: core_rpc_server_commands_defs.h:1708
cryptonote::COMMAND_RPC_GET_BLOCK_HEADERS_RANGE::response_t
Definition: core_rpc_server_commands_defs.h:1720
cryptonote::COMMAND_RPC_GET_BLOCK_HEADERS_RANGE::response_t::headers
std::vector< block_header_response > headers
Definition: core_rpc_server_commands_defs.h:1721
cryptonote::COMMAND_RPC_GET_BLOCK_HEADERS_RANGE
Definition: core_rpc_server_commands_defs.h:1703
cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HASH::request_t
Definition: core_rpc_server_commands_defs.h:1189
cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HASH::request_t::hash
std::string hash
Definition: core_rpc_server_commands_defs.h:1190
cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HASH::request_t::hashes
std::vector< std::string > hashes
Definition: core_rpc_server_commands_defs.h:1191
cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HASH::request_t::fill_pow_hash
bool fill_pow_hash
Definition: core_rpc_server_commands_defs.h:1192
cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HASH::response_t
Definition: core_rpc_server_commands_defs.h:1204
cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HASH::response_t::block_headers
std::vector< block_header_response > block_headers
Definition: core_rpc_server_commands_defs.h:1206
cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HASH::response_t::block_header
block_header_response block_header
Definition: core_rpc_server_commands_defs.h:1205
cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HASH
Definition: core_rpc_server_commands_defs.h:1187
cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HEIGHT::request_t
Definition: core_rpc_server_commands_defs.h:1220
cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HEIGHT::request_t::fill_pow_hash
bool fill_pow_hash
Definition: core_rpc_server_commands_defs.h:1222
cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HEIGHT::request_t::height
uint64_t height
Definition: core_rpc_server_commands_defs.h:1221
cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HEIGHT::response_t
Definition: core_rpc_server_commands_defs.h:1233
cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HEIGHT::response_t::block_header
block_header_response block_header
Definition: core_rpc_server_commands_defs.h:1234
cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HEIGHT
Definition: core_rpc_server_commands_defs.h:1218
cryptonote::COMMAND_RPC_GET_BLOCK
Definition: core_rpc_server_commands_defs.h:1245
cryptonote::COMMAND_RPC_GET_COINBASE_TX_SUM::request_t
Definition: core_rpc_server_commands_defs.h:2162
cryptonote::COMMAND_RPC_GET_COINBASE_TX_SUM::request_t::height
uint64_t height
Definition: core_rpc_server_commands_defs.h:2163
cryptonote::COMMAND_RPC_GET_COINBASE_TX_SUM::request_t::count
uint64_t count
Definition: core_rpc_server_commands_defs.h:2164
cryptonote::COMMAND_RPC_GET_COINBASE_TX_SUM::response_t
Definition: core_rpc_server_commands_defs.h:2175
cryptonote::COMMAND_RPC_GET_COINBASE_TX_SUM::response_t::wide_fee_amount
std::string wide_fee_amount
Definition: core_rpc_server_commands_defs.h:2180
cryptonote::COMMAND_RPC_GET_COINBASE_TX_SUM::response_t::wide_emission_amount
std::string wide_emission_amount
Definition: core_rpc_server_commands_defs.h:2177
cryptonote::COMMAND_RPC_GET_COINBASE_TX_SUM::response_t::fee_amount_top64
uint64_t fee_amount_top64
Definition: core_rpc_server_commands_defs.h:2181
cryptonote::COMMAND_RPC_GET_COINBASE_TX_SUM::response_t::emission_amount
uint64_t emission_amount
Definition: core_rpc_server_commands_defs.h:2176
cryptonote::COMMAND_RPC_GET_COINBASE_TX_SUM::response_t::emission_amount_top64
uint64_t emission_amount_top64
Definition: core_rpc_server_commands_defs.h:2178
cryptonote::COMMAND_RPC_GET_COINBASE_TX_SUM::response_t::fee_amount
uint64_t fee_amount
Definition: core_rpc_server_commands_defs.h:2179
cryptonote::COMMAND_RPC_GET_COINBASE_TX_SUM
Definition: core_rpc_server_commands_defs.h:2160
cryptonote::COMMAND_RPC_GET_CONNECTIONS::request_t
Definition: core_rpc_server_commands_defs.h:1683
cryptonote::COMMAND_RPC_GET_CONNECTIONS::response_t
Definition: core_rpc_server_commands_defs.h:1691
cryptonote::COMMAND_RPC_GET_CONNECTIONS::response_t::connections
std::list< connection_info > connections
Definition: core_rpc_server_commands_defs.h:1692
cryptonote::COMMAND_RPC_GET_CONNECTIONS
Definition: core_rpc_server_commands_defs.h:1681
cryptonote::COMMAND_RPC_GET_CONNECTIONS::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:1688
cryptonote::COMMAND_RPC_GET_HASHES_FAST::request_t
Definition: core_rpc_server_commands_defs.h:266
cryptonote::COMMAND_RPC_GET_HASHES_FAST::request_t::block_ids
std::list< crypto::hash > block_ids
Definition: core_rpc_server_commands_defs.h:267
cryptonote::COMMAND_RPC_GET_HASHES_FAST::request_t::start_height
uint64_t start_height
Definition: core_rpc_server_commands_defs.h:268
cryptonote::COMMAND_RPC_GET_HASHES_FAST::response_t
Definition: core_rpc_server_commands_defs.h:278
cryptonote::COMMAND_RPC_GET_HASHES_FAST::response_t::current_height
uint64_t current_height
Definition: core_rpc_server_commands_defs.h:281
cryptonote::COMMAND_RPC_GET_HASHES_FAST::response_t::m_block_ids
std::vector< crypto::hash > m_block_ids
Definition: core_rpc_server_commands_defs.h:279
cryptonote::COMMAND_RPC_GET_HASHES_FAST::response_t::start_height
uint64_t start_height
Definition: core_rpc_server_commands_defs.h:280
cryptonote::COMMAND_RPC_GET_HASHES_FAST
Definition: core_rpc_server_commands_defs.h:263
cryptonote::COMMAND_RPC_GET_HEIGHT::request_t
Definition: core_rpc_server_commands_defs.h:141
cryptonote::COMMAND_RPC_GET_HEIGHT::response_t
Definition: core_rpc_server_commands_defs.h:149
cryptonote::COMMAND_RPC_GET_HEIGHT::response_t::height
uint64_t height
Definition: core_rpc_server_commands_defs.h:150
cryptonote::COMMAND_RPC_GET_HEIGHT::response_t::hash
std::string hash
Definition: core_rpc_server_commands_defs.h:151
cryptonote::COMMAND_RPC_GET_HEIGHT
Definition: core_rpc_server_commands_defs.h:139
cryptonote::COMMAND_RPC_GET_HEIGHT::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:146
cryptonote::COMMAND_RPC_GET_INFO::request_t
Definition: core_rpc_server_commands_defs.h:645
cryptonote::COMMAND_RPC_GET_INFO::response_t
Definition: core_rpc_server_commands_defs.h:653
cryptonote::COMMAND_RPC_GET_INFO::response_t::difficulty_top64
uint64_t difficulty_top64
Definition: core_rpc_server_commands_defs.h:658
cryptonote::COMMAND_RPC_GET_INFO::response_t::block_size_limit
uint64_t block_size_limit
Definition: core_rpc_server_commands_defs.h:676
cryptonote::COMMAND_RPC_GET_INFO::response_t::cumulative_difficulty_top64
uint64_t cumulative_difficulty_top64
Definition: core_rpc_server_commands_defs.h:675
cryptonote::COMMAND_RPC_GET_INFO::response_t::free_space
uint64_t free_space
Definition: core_rpc_server_commands_defs.h:682
cryptonote::COMMAND_RPC_GET_INFO::response_t::busy_syncing
bool busy_syncing
Definition: core_rpc_server_commands_defs.h:689
cryptonote::COMMAND_RPC_GET_INFO::response_t::white_peerlist_size
uint64_t white_peerlist_size
Definition: core_rpc_server_commands_defs.h:666
cryptonote::COMMAND_RPC_GET_INFO::response_t::was_bootstrap_ever_used
bool was_bootstrap_ever_used
Definition: core_rpc_server_commands_defs.h:686
cryptonote::COMMAND_RPC_GET_INFO::response_t::bootstrap_daemon_address
std::string bootstrap_daemon_address
Definition: core_rpc_server_commands_defs.h:684
cryptonote::COMMAND_RPC_GET_INFO::response_t::target
uint64_t target
Definition: core_rpc_server_commands_defs.h:659
cryptonote::COMMAND_RPC_GET_INFO::response_t::update_available
bool update_available
Definition: core_rpc_server_commands_defs.h:688
cryptonote::COMMAND_RPC_GET_INFO::response_t::block_size_median
uint64_t block_size_median
Definition: core_rpc_server_commands_defs.h:678
cryptonote::COMMAND_RPC_GET_INFO::response_t::offline
bool offline
Definition: core_rpc_server_commands_defs.h:683
cryptonote::COMMAND_RPC_GET_INFO::response_t::version
std::string version
Definition: core_rpc_server_commands_defs.h:690
cryptonote::COMMAND_RPC_GET_INFO::response_t::block_weight_median
uint64_t block_weight_median
Definition: core_rpc_server_commands_defs.h:679
cryptonote::COMMAND_RPC_GET_INFO::response_t::start_time
uint64_t start_time
Definition: core_rpc_server_commands_defs.h:681
cryptonote::COMMAND_RPC_GET_INFO::response_t::adjusted_time
uint64_t adjusted_time
Definition: core_rpc_server_commands_defs.h:680
cryptonote::COMMAND_RPC_GET_INFO::response_t::target_height
uint64_t target_height
Definition: core_rpc_server_commands_defs.h:655
cryptonote::COMMAND_RPC_GET_INFO::response_t::wide_difficulty
std::string wide_difficulty
Definition: core_rpc_server_commands_defs.h:657
cryptonote::COMMAND_RPC_GET_INFO::response_t::outgoing_connections_count
uint64_t outgoing_connections_count
Definition: core_rpc_server_commands_defs.h:663
cryptonote::COMMAND_RPC_GET_INFO::response_t::top_block_hash
std::string top_block_hash
Definition: core_rpc_server_commands_defs.h:672
cryptonote::COMMAND_RPC_GET_INFO::response_t::database_size
uint64_t database_size
Definition: core_rpc_server_commands_defs.h:687
cryptonote::COMMAND_RPC_GET_INFO::response_t::wide_cumulative_difficulty
std::string wide_cumulative_difficulty
Definition: core_rpc_server_commands_defs.h:674
cryptonote::COMMAND_RPC_GET_INFO::response_t::block_weight_limit
uint64_t block_weight_limit
Definition: core_rpc_server_commands_defs.h:677
cryptonote::COMMAND_RPC_GET_INFO::response_t::testnet
bool testnet
Definition: core_rpc_server_commands_defs.h:669
cryptonote::COMMAND_RPC_GET_INFO::response_t::incoming_connections_count
uint64_t incoming_connections_count
Definition: core_rpc_server_commands_defs.h:664
cryptonote::COMMAND_RPC_GET_INFO::response_t::difficulty
uint64_t difficulty
Definition: core_rpc_server_commands_defs.h:656
cryptonote::COMMAND_RPC_GET_INFO::response_t::tx_pool_size
uint64_t tx_pool_size
Definition: core_rpc_server_commands_defs.h:661
cryptonote::COMMAND_RPC_GET_INFO::response_t::grey_peerlist_size
uint64_t grey_peerlist_size
Definition: core_rpc_server_commands_defs.h:667
cryptonote::COMMAND_RPC_GET_INFO::response_t::cumulative_difficulty
uint64_t cumulative_difficulty
Definition: core_rpc_server_commands_defs.h:673
cryptonote::COMMAND_RPC_GET_INFO::response_t::mainnet
bool mainnet
Definition: core_rpc_server_commands_defs.h:668
cryptonote::COMMAND_RPC_GET_INFO::response_t::alt_blocks_count
uint64_t alt_blocks_count
Definition: core_rpc_server_commands_defs.h:662
cryptonote::COMMAND_RPC_GET_INFO::response_t::restricted
bool restricted
Definition: core_rpc_server_commands_defs.h:692
cryptonote::COMMAND_RPC_GET_INFO::response_t::stagenet
bool stagenet
Definition: core_rpc_server_commands_defs.h:670
cryptonote::COMMAND_RPC_GET_INFO::response_t::height
uint64_t height
Definition: core_rpc_server_commands_defs.h:654
cryptonote::COMMAND_RPC_GET_INFO::response_t::rpc_connections_count
uint64_t rpc_connections_count
Definition: core_rpc_server_commands_defs.h:665
cryptonote::COMMAND_RPC_GET_INFO::response_t::nettype
std::string nettype
Definition: core_rpc_server_commands_defs.h:671
cryptonote::COMMAND_RPC_GET_INFO::response_t::height_without_bootstrap
uint64_t height_without_bootstrap
Definition: core_rpc_server_commands_defs.h:685
cryptonote::COMMAND_RPC_GET_INFO::response_t::tx_count
uint64_t tx_count
Definition: core_rpc_server_commands_defs.h:660
cryptonote::COMMAND_RPC_GET_INFO
Definition: core_rpc_server_commands_defs.h:643
cryptonote::COMMAND_RPC_GET_LAST_BLOCK_HEADER::request_t
Definition: core_rpc_server_commands_defs.h:1163
cryptonote::COMMAND_RPC_GET_LAST_BLOCK_HEADER::request_t::fill_pow_hash
bool fill_pow_hash
Definition: core_rpc_server_commands_defs.h:1164
cryptonote::COMMAND_RPC_GET_LAST_BLOCK_HEADER::response_t
Definition: core_rpc_server_commands_defs.h:1174
cryptonote::COMMAND_RPC_GET_LAST_BLOCK_HEADER::response_t::block_header
block_header_response block_header
Definition: core_rpc_server_commands_defs.h:1175
cryptonote::COMMAND_RPC_GET_LAST_BLOCK_HEADER
Definition: core_rpc_server_commands_defs.h:1161
cryptonote::COMMAND_RPC_GET_LIMIT::request_t
Definition: core_rpc_server_commands_defs.h:1801
cryptonote::COMMAND_RPC_GET_LIMIT::response_t
Definition: core_rpc_server_commands_defs.h:1809
cryptonote::COMMAND_RPC_GET_LIMIT::response_t::limit_up
uint64_t limit_up
Definition: core_rpc_server_commands_defs.h:1810
cryptonote::COMMAND_RPC_GET_LIMIT::response_t::limit_down
uint64_t limit_down
Definition: core_rpc_server_commands_defs.h:1811
cryptonote::COMMAND_RPC_GET_LIMIT
Definition: core_rpc_server_commands_defs.h:1799
cryptonote::COMMAND_RPC_GET_LIMIT::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:1806
cryptonote::COMMAND_RPC_GET_NET_STATS::request_t
Definition: core_rpc_server_commands_defs.h:745
cryptonote::COMMAND_RPC_GET_NET_STATS::response_t
Definition: core_rpc_server_commands_defs.h:754
cryptonote::COMMAND_RPC_GET_NET_STATS::response_t::total_bytes_out
uint64_t total_bytes_out
Definition: core_rpc_server_commands_defs.h:759
cryptonote::COMMAND_RPC_GET_NET_STATS::response_t::start_time
uint64_t start_time
Definition: core_rpc_server_commands_defs.h:755
cryptonote::COMMAND_RPC_GET_NET_STATS::response_t::total_bytes_in
uint64_t total_bytes_in
Definition: core_rpc_server_commands_defs.h:757
cryptonote::COMMAND_RPC_GET_NET_STATS::response_t::total_packets_in
uint64_t total_packets_in
Definition: core_rpc_server_commands_defs.h:756
cryptonote::COMMAND_RPC_GET_NET_STATS::response_t::total_packets_out
uint64_t total_packets_out
Definition: core_rpc_server_commands_defs.h:758
cryptonote::COMMAND_RPC_GET_NET_STATS
Definition: core_rpc_server_commands_defs.h:743
cryptonote::COMMAND_RPC_GET_NET_STATS::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:750
cryptonote::COMMAND_RPC_GET_OUTPUTS::outkey
Definition: core_rpc_server_commands_defs.h:536
cryptonote::COMMAND_RPC_GET_OUTPUTS::outkey::mask
std::string mask
Definition: core_rpc_server_commands_defs.h:538
cryptonote::COMMAND_RPC_GET_OUTPUTS::outkey::unlocked
bool unlocked
Definition: core_rpc_server_commands_defs.h:539
cryptonote::COMMAND_RPC_GET_OUTPUTS::outkey::height
uint64_t height
Definition: core_rpc_server_commands_defs.h:540
cryptonote::COMMAND_RPC_GET_OUTPUTS::outkey::key
std::string key
Definition: core_rpc_server_commands_defs.h:537
cryptonote::COMMAND_RPC_GET_OUTPUTS::outkey::txid
std::string txid
Definition: core_rpc_server_commands_defs.h:541
cryptonote::COMMAND_RPC_GET_OUTPUTS::request_t
Definition: core_rpc_server_commands_defs.h:523
cryptonote::COMMAND_RPC_GET_OUTPUTS::request_t::outputs
std::vector< get_outputs_out > outputs
Definition: core_rpc_server_commands_defs.h:524
cryptonote::COMMAND_RPC_GET_OUTPUTS::request_t::get_txid
bool get_txid
Definition: core_rpc_server_commands_defs.h:525
cryptonote::COMMAND_RPC_GET_OUTPUTS::response_t
Definition: core_rpc_server_commands_defs.h:553
cryptonote::COMMAND_RPC_GET_OUTPUTS::response_t::outs
std::vector< outkey > outs
Definition: core_rpc_server_commands_defs.h:554
cryptonote::COMMAND_RPC_GET_OUTPUTS_BIN::outkey
Definition: core_rpc_server_commands_defs.h:492
cryptonote::COMMAND_RPC_GET_OUTPUTS_BIN::outkey::key
crypto::public_key key
Definition: core_rpc_server_commands_defs.h:493
cryptonote::COMMAND_RPC_GET_OUTPUTS_BIN::outkey::mask
rct::key mask
Definition: core_rpc_server_commands_defs.h:494
cryptonote::COMMAND_RPC_GET_OUTPUTS_BIN::outkey::height
uint64_t height
Definition: core_rpc_server_commands_defs.h:496
cryptonote::COMMAND_RPC_GET_OUTPUTS_BIN::outkey::unlocked
bool unlocked
Definition: core_rpc_server_commands_defs.h:495
cryptonote::COMMAND_RPC_GET_OUTPUTS_BIN::outkey::txid
crypto::hash txid
Definition: core_rpc_server_commands_defs.h:497
cryptonote::COMMAND_RPC_GET_OUTPUTS_BIN::request_t
Definition: core_rpc_server_commands_defs.h:479
cryptonote::COMMAND_RPC_GET_OUTPUTS_BIN::request_t::outputs
std::vector< get_outputs_out > outputs
Definition: core_rpc_server_commands_defs.h:480
cryptonote::COMMAND_RPC_GET_OUTPUTS_BIN::request_t::get_txid
bool get_txid
Definition: core_rpc_server_commands_defs.h:481
cryptonote::COMMAND_RPC_GET_OUTPUTS_BIN::response_t
Definition: core_rpc_server_commands_defs.h:509
cryptonote::COMMAND_RPC_GET_OUTPUTS_BIN::response_t::outs
std::vector< outkey > outs
Definition: core_rpc_server_commands_defs.h:510
cryptonote::COMMAND_RPC_GET_OUTPUTS_BIN
Definition: core_rpc_server_commands_defs.h:477
cryptonote::COMMAND_RPC_GET_OUTPUTS
Definition: core_rpc_server_commands_defs.h:521
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::distribution
Definition: core_rpc_server_commands_defs.h:2415
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::distribution::binary
bool binary
Definition: core_rpc_server_commands_defs.h:2419
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::distribution::data
rpc::output_distribution_data data
Definition: core_rpc_server_commands_defs.h:2416
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::distribution::compressed_data
std::string compressed_data
Definition: core_rpc_server_commands_defs.h:2418
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::distribution::compress
bool compress
Definition: core_rpc_server_commands_defs.h:2420
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::distribution::amount
uint64_t amount
Definition: core_rpc_server_commands_defs.h:2417
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::request_t
Definition: core_rpc_server_commands_defs.h:2394
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::request_t::from_height
uint64_t from_height
Definition: core_rpc_server_commands_defs.h:2396
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::request_t::compress
bool compress
Definition: core_rpc_server_commands_defs.h:2400
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::request_t::to_height
uint64_t to_height
Definition: core_rpc_server_commands_defs.h:2397
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::request_t::binary
bool binary
Definition: core_rpc_server_commands_defs.h:2399
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::request_t::amounts
std::vector< uint64_t > amounts
Definition: core_rpc_server_commands_defs.h:2395
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::request_t::cumulative
bool cumulative
Definition: core_rpc_server_commands_defs.h:2398
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::response_t
Definition: core_rpc_server_commands_defs.h:2457
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::response_t::distributions
std::vector< distribution > distributions
Definition: core_rpc_server_commands_defs.h:2458
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION
Definition: core_rpc_server_commands_defs.h:2392
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::entry
Definition: core_rpc_server_commands_defs.h:2086
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::entry::unlocked_instances
uint64_t unlocked_instances
Definition: core_rpc_server_commands_defs.h:2089
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::entry::recent_instances
uint64_t recent_instances
Definition: core_rpc_server_commands_defs.h:2090
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::entry::total_instances
uint64_t total_instances
Definition: core_rpc_server_commands_defs.h:2088
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::entry::entry
entry()
Definition: core_rpc_server_commands_defs.h:2101
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::entry::amount
uint64_t amount
Definition: core_rpc_server_commands_defs.h:2087
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::request_t
Definition: core_rpc_server_commands_defs.h:2067
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::request_t::max_count
uint64_t max_count
Definition: core_rpc_server_commands_defs.h:2070
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::request_t::min_count
uint64_t min_count
Definition: core_rpc_server_commands_defs.h:2069
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::request_t::unlocked
bool unlocked
Definition: core_rpc_server_commands_defs.h:2071
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::request_t::recent_cutoff
uint64_t recent_cutoff
Definition: core_rpc_server_commands_defs.h:2072
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::request_t::amounts
std::vector< uint64_t > amounts
Definition: core_rpc_server_commands_defs.h:2068
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::response_t
Definition: core_rpc_server_commands_defs.h:2105
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::response_t::histogram
std::vector< entry > histogram
Definition: core_rpc_server_commands_defs.h:2106
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM
Definition: core_rpc_server_commands_defs.h:2065
cryptonote::COMMAND_RPC_GET_PEER_LIST::request_t
Definition: core_rpc_server_commands_defs.h:1318
cryptonote::COMMAND_RPC_GET_PEER_LIST::request_t::public_only
bool public_only
Definition: core_rpc_server_commands_defs.h:1319
cryptonote::COMMAND_RPC_GET_PEER_LIST::request_t::include_blocked
bool include_blocked
Definition: core_rpc_server_commands_defs.h:1320
cryptonote::COMMAND_RPC_GET_PEER_LIST::response_t
Definition: core_rpc_server_commands_defs.h:1331
cryptonote::COMMAND_RPC_GET_PEER_LIST::response_t::white_list
std::vector< peer > white_list
Definition: core_rpc_server_commands_defs.h:1332
cryptonote::COMMAND_RPC_GET_PEER_LIST::response_t::gray_list
std::vector< peer > gray_list
Definition: core_rpc_server_commands_defs.h:1333
cryptonote::COMMAND_RPC_GET_PEER_LIST
Definition: core_rpc_server_commands_defs.h:1316
cryptonote::COMMAND_RPC_GET_PUBLIC_NODES::request_t
Definition: core_rpc_server_commands_defs.h:1368
cryptonote::COMMAND_RPC_GET_PUBLIC_NODES::request_t::gray
bool gray
Definition: core_rpc_server_commands_defs.h:1369
cryptonote::COMMAND_RPC_GET_PUBLIC_NODES::request_t::include_blocked
bool include_blocked
Definition: core_rpc_server_commands_defs.h:1371
cryptonote::COMMAND_RPC_GET_PUBLIC_NODES::request_t::white
bool white
Definition: core_rpc_server_commands_defs.h:1370
cryptonote::COMMAND_RPC_GET_PUBLIC_NODES::response_t
Definition: core_rpc_server_commands_defs.h:1383
cryptonote::COMMAND_RPC_GET_PUBLIC_NODES::response_t::gray
std::vector< public_node > gray
Definition: core_rpc_server_commands_defs.h:1384
cryptonote::COMMAND_RPC_GET_PUBLIC_NODES::response_t::white
std::vector< public_node > white
Definition: core_rpc_server_commands_defs.h:1385
cryptonote::COMMAND_RPC_GET_PUBLIC_NODES
Definition: core_rpc_server_commands_defs.h:1366
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::entry
Definition: core_rpc_server_commands_defs.h:343
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::entry::confirmations
uint64_t confirmations
Definition: core_rpc_server_commands_defs.h:353
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::entry::block_height
uint64_t block_height
Definition: core_rpc_server_commands_defs.h:352
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::entry::as_json
std::string as_json
Definition: core_rpc_server_commands_defs.h:349
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::entry::in_pool
bool in_pool
Definition: core_rpc_server_commands_defs.h:350
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::entry::relayed
bool relayed
Definition: core_rpc_server_commands_defs.h:357
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::entry::received_timestamp
uint64_t received_timestamp
Definition: core_rpc_server_commands_defs.h:355
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::entry::as_hex
std::string as_hex
Definition: core_rpc_server_commands_defs.h:345
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::entry::prunable_as_hex
std::string prunable_as_hex
Definition: core_rpc_server_commands_defs.h:347
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::entry::prunable_hash
std::string prunable_hash
Definition: core_rpc_server_commands_defs.h:348
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::entry::output_indices
std::vector< uint64_t > output_indices
Definition: core_rpc_server_commands_defs.h:356
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::entry::pruned_as_hex
std::string pruned_as_hex
Definition: core_rpc_server_commands_defs.h:346
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::entry::tx_hash
std::string tx_hash
Definition: core_rpc_server_commands_defs.h:344
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::entry::block_timestamp
uint64_t block_timestamp
Definition: core_rpc_server_commands_defs.h:354
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::entry::double_spend_seen
bool double_spend_seen
Definition: core_rpc_server_commands_defs.h:351
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::request_t
Definition: core_rpc_server_commands_defs.h:326
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::request_t::split
bool split
Definition: core_rpc_server_commands_defs.h:330
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::request_t::txs_hashes
std::vector< std::string > txs_hashes
Definition: core_rpc_server_commands_defs.h:327
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::request_t::prune
bool prune
Definition: core_rpc_server_commands_defs.h:329
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::request_t::decode_as_json
bool decode_as_json
Definition: core_rpc_server_commands_defs.h:328
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::response_t
Definition: core_rpc_server_commands_defs.h:384
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::response_t::txs_as_hex
std::vector< std::string > txs_as_hex
Definition: core_rpc_server_commands_defs.h:386
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::response_t::txs_as_json
std::vector< std::string > txs_as_json
Definition: core_rpc_server_commands_defs.h:387
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::response_t::txs
std::vector< entry > txs
Definition: core_rpc_server_commands_defs.h:393
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::response_t::missed_tx
std::vector< std::string > missed_tx
Definition: core_rpc_server_commands_defs.h:390
cryptonote::COMMAND_RPC_GET_TRANSACTIONS
Definition: core_rpc_server_commands_defs.h:324
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL::request_t
Definition: core_rpc_server_commands_defs.h:1518
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL::response_t
Definition: core_rpc_server_commands_defs.h:1526
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL::response_t::spent_key_images
std::vector< spent_key_image_info > spent_key_images
Definition: core_rpc_server_commands_defs.h:1528
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL::response_t::transactions
std::vector< tx_info > transactions
Definition: core_rpc_server_commands_defs.h:1527
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_BACKLOG::request_t
Definition: core_rpc_server_commands_defs.h:1593
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_BACKLOG::response_t
Definition: core_rpc_server_commands_defs.h:1601
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_BACKLOG::response_t::backlog
std::vector< tx_backlog_entry > backlog
Definition: core_rpc_server_commands_defs.h:1602
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_BACKLOG
Definition: core_rpc_server_commands_defs.h:1591
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_BACKLOG::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:1598
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_HASHES::request_t
Definition: core_rpc_server_commands_defs.h:1564
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_HASHES::response_t
Definition: core_rpc_server_commands_defs.h:1572
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_HASHES::response_t::tx_hashes
std::vector< std::string > tx_hashes
Definition: core_rpc_server_commands_defs.h:1573
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_HASHES_BIN::request_t
Definition: core_rpc_server_commands_defs.h:1542
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_HASHES_BIN::response_t
Definition: core_rpc_server_commands_defs.h:1550
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_HASHES_BIN::response_t::tx_hashes
std::vector< crypto::hash > tx_hashes
Definition: core_rpc_server_commands_defs.h:1551
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_HASHES_BIN
Definition: core_rpc_server_commands_defs.h:1540
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_HASHES_BIN::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:1547
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_HASHES
Definition: core_rpc_server_commands_defs.h:1562
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_HASHES::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:1569
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_STATS::request_t
Definition: core_rpc_server_commands_defs.h:1661
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_STATS::response_t
Definition: core_rpc_server_commands_defs.h:1669
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_STATS::response_t::pool_stats
txpool_stats pool_stats
Definition: core_rpc_server_commands_defs.h:1670
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_STATS
Definition: core_rpc_server_commands_defs.h:1659
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_STATS::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:1666
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL
Definition: core_rpc_server_commands_defs.h:1516
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:1523
cryptonote::COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES::request_t
Definition: core_rpc_server_commands_defs.h:443
cryptonote::COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES::request_t::txid
crypto::hash txid
Definition: core_rpc_server_commands_defs.h:444
cryptonote::COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES::response_t
Definition: core_rpc_server_commands_defs.h:454
cryptonote::COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES::response_t::o_indexes
std::vector< uint64_t > o_indexes
Definition: core_rpc_server_commands_defs.h:455
cryptonote::COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES
Definition: core_rpc_server_commands_defs.h:441
cryptonote::COMMAND_RPC_GET_VERSION::hf_entry
Definition: core_rpc_server_commands_defs.h:2127
cryptonote::COMMAND_RPC_GET_VERSION::hf_entry::height
uint64_t height
Definition: core_rpc_server_commands_defs.h:2129
cryptonote::COMMAND_RPC_GET_VERSION::hf_entry::hf_version
uint8_t hf_version
Definition: core_rpc_server_commands_defs.h:2128
cryptonote::COMMAND_RPC_GET_VERSION::hf_entry::operator==
bool operator==(const hf_entry &hfe) const
Definition: core_rpc_server_commands_defs.h:2131
cryptonote::COMMAND_RPC_GET_VERSION::request_t
Definition: core_rpc_server_commands_defs.h:2119
cryptonote::COMMAND_RPC_GET_VERSION::response_t
Definition: core_rpc_server_commands_defs.h:2140
cryptonote::COMMAND_RPC_GET_VERSION::response_t::release
bool release
Definition: core_rpc_server_commands_defs.h:2142
cryptonote::COMMAND_RPC_GET_VERSION::response_t::version
uint32_t version
Definition: core_rpc_server_commands_defs.h:2141
cryptonote::COMMAND_RPC_GET_VERSION::response_t::current_height
uint64_t current_height
Definition: core_rpc_server_commands_defs.h:2143
cryptonote::COMMAND_RPC_GET_VERSION::response_t::target_height
uint64_t target_height
Definition: core_rpc_server_commands_defs.h:2144
cryptonote::COMMAND_RPC_GET_VERSION::response_t::hard_forks
std::vector< hf_entry > hard_forks
Definition: core_rpc_server_commands_defs.h:2145
cryptonote::COMMAND_RPC_GET_VERSION
Definition: core_rpc_server_commands_defs.h:2117
cryptonote::COMMAND_RPC_GET_VERSION::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:2124
cryptonote::COMMAND_RPC_HARD_FORK_INFO::request_t
Definition: core_rpc_server_commands_defs.h:1907
cryptonote::COMMAND_RPC_HARD_FORK_INFO::request_t::version
uint8_t version
Definition: core_rpc_server_commands_defs.h:1908
cryptonote::COMMAND_RPC_HARD_FORK_INFO::response_t
Definition: core_rpc_server_commands_defs.h:1918
cryptonote::COMMAND_RPC_HARD_FORK_INFO::response_t::state
uint32_t state
Definition: core_rpc_server_commands_defs.h:1925
cryptonote::COMMAND_RPC_HARD_FORK_INFO::response_t::enabled
bool enabled
Definition: core_rpc_server_commands_defs.h:1920
cryptonote::COMMAND_RPC_HARD_FORK_INFO::response_t::window
uint32_t window
Definition: core_rpc_server_commands_defs.h:1921
cryptonote::COMMAND_RPC_HARD_FORK_INFO::response_t::voting
uint8_t voting
Definition: core_rpc_server_commands_defs.h:1924
cryptonote::COMMAND_RPC_HARD_FORK_INFO::response_t::votes
uint32_t votes
Definition: core_rpc_server_commands_defs.h:1922
cryptonote::COMMAND_RPC_HARD_FORK_INFO::response_t::version
uint8_t version
Definition: core_rpc_server_commands_defs.h:1919
cryptonote::COMMAND_RPC_HARD_FORK_INFO::response_t::earliest_height
uint64_t earliest_height
Definition: core_rpc_server_commands_defs.h:1926
cryptonote::COMMAND_RPC_HARD_FORK_INFO::response_t::threshold
uint32_t threshold
Definition: core_rpc_server_commands_defs.h:1923
cryptonote::COMMAND_RPC_HARD_FORK_INFO
Definition: core_rpc_server_commands_defs.h:1905
cryptonote::COMMAND_RPC_IN_PEERS::request_t
Definition: core_rpc_server_commands_defs.h:1881
cryptonote::COMMAND_RPC_IN_PEERS::request_t::in_peers
uint32_t in_peers
Definition: core_rpc_server_commands_defs.h:1883
cryptonote::COMMAND_RPC_IN_PEERS::request_t::set
bool set
Definition: core_rpc_server_commands_defs.h:1882
cryptonote::COMMAND_RPC_IN_PEERS::response_t
Definition: core_rpc_server_commands_defs.h:1893
cryptonote::COMMAND_RPC_IN_PEERS::response_t::in_peers
uint32_t in_peers
Definition: core_rpc_server_commands_defs.h:1894
cryptonote::COMMAND_RPC_IN_PEERS
Definition: core_rpc_server_commands_defs.h:1879
cryptonote::COMMAND_RPC_IS_KEY_IMAGE_SPENT::request_t
Definition: core_rpc_server_commands_defs.h:416
cryptonote::COMMAND_RPC_IS_KEY_IMAGE_SPENT::request_t::key_images
std::vector< std::string > key_images
Definition: core_rpc_server_commands_defs.h:417
cryptonote::COMMAND_RPC_IS_KEY_IMAGE_SPENT::response_t
Definition: core_rpc_server_commands_defs.h:428
cryptonote::COMMAND_RPC_IS_KEY_IMAGE_SPENT::response_t::spent_status
std::vector< int > spent_status
Definition: core_rpc_server_commands_defs.h:429
cryptonote::COMMAND_RPC_IS_KEY_IMAGE_SPENT
Definition: core_rpc_server_commands_defs.h:408
cryptonote::COMMAND_RPC_IS_KEY_IMAGE_SPENT::STATUS
STATUS
Definition: core_rpc_server_commands_defs.h:409
cryptonote::COMMAND_RPC_MINING_STATUS::request_t
Definition: core_rpc_server_commands_defs.h:798
cryptonote::COMMAND_RPC_MINING_STATUS::response_t
Definition: core_rpc_server_commands_defs.h:807
cryptonote::COMMAND_RPC_MINING_STATUS::response_t::threads_count
uint32_t threads_count
Definition: core_rpc_server_commands_defs.h:810
cryptonote::COMMAND_RPC_MINING_STATUS::response_t::bg_ignore_battery
bool bg_ignore_battery
Definition: core_rpc_server_commands_defs.h:816
cryptonote::COMMAND_RPC_MINING_STATUS::response_t::active
bool active
Definition: core_rpc_server_commands_defs.h:808
cryptonote::COMMAND_RPC_MINING_STATUS::response_t::difficulty
uint64_t difficulty
Definition: core_rpc_server_commands_defs.h:820
cryptonote::COMMAND_RPC_MINING_STATUS::response_t::speed
uint64_t speed
Definition: core_rpc_server_commands_defs.h:809
cryptonote::COMMAND_RPC_MINING_STATUS::response_t::bg_idle_threshold
uint8_t bg_idle_threshold
Definition: core_rpc_server_commands_defs.h:814
cryptonote::COMMAND_RPC_MINING_STATUS::response_t::is_background_mining_enabled
bool is_background_mining_enabled
Definition: core_rpc_server_commands_defs.h:813
cryptonote::COMMAND_RPC_MINING_STATUS::response_t::block_reward
uint64_t block_reward
Definition: core_rpc_server_commands_defs.h:819
cryptonote::COMMAND_RPC_MINING_STATUS::response_t::difficulty_top64
uint64_t difficulty_top64
Definition: core_rpc_server_commands_defs.h:822
cryptonote::COMMAND_RPC_MINING_STATUS::response_t::pow_algorithm
std::string pow_algorithm
Definition: core_rpc_server_commands_defs.h:812
cryptonote::COMMAND_RPC_MINING_STATUS::response_t::wide_difficulty
std::string wide_difficulty
Definition: core_rpc_server_commands_defs.h:821
cryptonote::COMMAND_RPC_MINING_STATUS::response_t::block_target
uint32_t block_target
Definition: core_rpc_server_commands_defs.h:818
cryptonote::COMMAND_RPC_MINING_STATUS::response_t::bg_target
uint8_t bg_target
Definition: core_rpc_server_commands_defs.h:817
cryptonote::COMMAND_RPC_MINING_STATUS::response_t::bg_min_idle_seconds
uint8_t bg_min_idle_seconds
Definition: core_rpc_server_commands_defs.h:815
cryptonote::COMMAND_RPC_MINING_STATUS::response_t::address
std::string address
Definition: core_rpc_server_commands_defs.h:811
cryptonote::COMMAND_RPC_MINING_STATUS
Definition: core_rpc_server_commands_defs.h:796
cryptonote::COMMAND_RPC_MINING_STATUS::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:803
cryptonote::COMMAND_RPC_OUT_PEERS::request_t
Definition: core_rpc_server_commands_defs.h:1854
cryptonote::COMMAND_RPC_OUT_PEERS::request_t::out_peers
uint32_t out_peers
Definition: core_rpc_server_commands_defs.h:1856
cryptonote::COMMAND_RPC_OUT_PEERS::request_t::set
bool set
Definition: core_rpc_server_commands_defs.h:1855
cryptonote::COMMAND_RPC_OUT_PEERS::response_t
Definition: core_rpc_server_commands_defs.h:1867
cryptonote::COMMAND_RPC_OUT_PEERS::response_t::out_peers
uint32_t out_peers
Definition: core_rpc_server_commands_defs.h:1868
cryptonote::COMMAND_RPC_OUT_PEERS
Definition: core_rpc_server_commands_defs.h:1852
cryptonote::COMMAND_RPC_POP_BLOCKS::request_t
Definition: core_rpc_server_commands_defs.h:2671
cryptonote::COMMAND_RPC_POP_BLOCKS::request_t::nblocks
uint64_t nblocks
Definition: core_rpc_server_commands_defs.h:2672
cryptonote::COMMAND_RPC_POP_BLOCKS::response_t
Definition: core_rpc_server_commands_defs.h:2682
cryptonote::COMMAND_RPC_POP_BLOCKS::response_t::height
uint64_t height
Definition: core_rpc_server_commands_defs.h:2683
cryptonote::COMMAND_RPC_POP_BLOCKS
Definition: core_rpc_server_commands_defs.h:2669
cryptonote::COMMAND_RPC_PRUNE_BLOCKCHAIN::request_t
Definition: core_rpc_server_commands_defs.h:2696
cryptonote::COMMAND_RPC_PRUNE_BLOCKCHAIN::request_t::check
bool check
Definition: core_rpc_server_commands_defs.h:2697
cryptonote::COMMAND_RPC_PRUNE_BLOCKCHAIN::response_t
Definition: core_rpc_server_commands_defs.h:2707
cryptonote::COMMAND_RPC_PRUNE_BLOCKCHAIN::response_t::pruned
bool pruned
Definition: core_rpc_server_commands_defs.h:2708
cryptonote::COMMAND_RPC_PRUNE_BLOCKCHAIN::response_t::pruning_seed
uint32_t pruning_seed
Definition: core_rpc_server_commands_defs.h:2709
cryptonote::COMMAND_RPC_PRUNE_BLOCKCHAIN
Definition: core_rpc_server_commands_defs.h:2694
cryptonote::COMMAND_RPC_RELAY_TX::request_t
Definition: core_rpc_server_commands_defs.h:2310
cryptonote::COMMAND_RPC_RELAY_TX::request_t::txids
std::vector< std::string > txids
Definition: core_rpc_server_commands_defs.h:2311
cryptonote::COMMAND_RPC_RELAY_TX::response_t
Definition: core_rpc_server_commands_defs.h:2321
cryptonote::COMMAND_RPC_RELAY_TX
Definition: core_rpc_server_commands_defs.h:2308
cryptonote::COMMAND_RPC_RELAY_TX::response
epee::misc_utils::struct_init< response_t > response
Definition: core_rpc_server_commands_defs.h:2326
cryptonote::COMMAND_RPC_SAVE_BC::request_t
Definition: core_rpc_server_commands_defs.h:850
cryptonote::COMMAND_RPC_SAVE_BC::response_t
Definition: core_rpc_server_commands_defs.h:859
cryptonote::COMMAND_RPC_SAVE_BC
Definition: core_rpc_server_commands_defs.h:848
cryptonote::COMMAND_RPC_SAVE_BC::response
epee::misc_utils::struct_init< response_t > response
Definition: core_rpc_server_commands_defs.h:864
cryptonote::COMMAND_RPC_SAVE_BC::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:855
cryptonote::COMMAND_RPC_SEND_RAW_TX::request_t
Definition: core_rpc_server_commands_defs.h:567
cryptonote::COMMAND_RPC_SEND_RAW_TX::request_t::do_not_relay
bool do_not_relay
Definition: core_rpc_server_commands_defs.h:569
cryptonote::COMMAND_RPC_SEND_RAW_TX::request_t::do_sanity_checks
bool do_sanity_checks
Definition: core_rpc_server_commands_defs.h:570
cryptonote::COMMAND_RPC_SEND_RAW_TX::request_t::tx_as_hex
std::string tx_as_hex
Definition: core_rpc_server_commands_defs.h:568
cryptonote::COMMAND_RPC_SEND_RAW_TX::response_t
Definition: core_rpc_server_commands_defs.h:583
cryptonote::COMMAND_RPC_SEND_RAW_TX::response_t::sanity_check_failed
bool sanity_check_failed
Definition: core_rpc_server_commands_defs.h:594
cryptonote::COMMAND_RPC_SEND_RAW_TX::response_t::not_relayed
bool not_relayed
Definition: core_rpc_server_commands_defs.h:585
cryptonote::COMMAND_RPC_SEND_RAW_TX::response_t::fee_too_low
bool fee_too_low
Definition: core_rpc_server_commands_defs.h:592
cryptonote::COMMAND_RPC_SEND_RAW_TX::response_t::invalid_input
bool invalid_input
Definition: core_rpc_server_commands_defs.h:588
cryptonote::COMMAND_RPC_SEND_RAW_TX::response_t::low_mixin
bool low_mixin
Definition: core_rpc_server_commands_defs.h:586
cryptonote::COMMAND_RPC_SEND_RAW_TX::response_t::too_few_outputs
bool too_few_outputs
Definition: core_rpc_server_commands_defs.h:593
cryptonote::COMMAND_RPC_SEND_RAW_TX::response_t::double_spend
bool double_spend
Definition: core_rpc_server_commands_defs.h:587
cryptonote::COMMAND_RPC_SEND_RAW_TX::response_t::overspend
bool overspend
Definition: core_rpc_server_commands_defs.h:591
cryptonote::COMMAND_RPC_SEND_RAW_TX::response_t::invalid_output
bool invalid_output
Definition: core_rpc_server_commands_defs.h:589
cryptonote::COMMAND_RPC_SEND_RAW_TX::response_t::reason
std::string reason
Definition: core_rpc_server_commands_defs.h:584
cryptonote::COMMAND_RPC_SEND_RAW_TX::response_t::too_big
bool too_big
Definition: core_rpc_server_commands_defs.h:590
cryptonote::COMMAND_RPC_SEND_RAW_TX
Definition: core_rpc_server_commands_defs.h:565
cryptonote::COMMAND_RPC_SETBANS::ban
Definition: core_rpc_server_commands_defs.h:1981
cryptonote::COMMAND_RPC_SETBANS::ban::seconds
uint32_t seconds
Definition: core_rpc_server_commands_defs.h:1985
cryptonote::COMMAND_RPC_SETBANS::ban::ip
uint32_t ip
Definition: core_rpc_server_commands_defs.h:1983
cryptonote::COMMAND_RPC_SETBANS::ban::ban
bool ban
Definition: core_rpc_server_commands_defs.h:1984
cryptonote::COMMAND_RPC_SETBANS::ban::host
std::string host
Definition: core_rpc_server_commands_defs.h:1982
cryptonote::COMMAND_RPC_SETBANS::request_t
Definition: core_rpc_server_commands_defs.h:1996
cryptonote::COMMAND_RPC_SETBANS::request_t::bans
std::vector< ban > bans
Definition: core_rpc_server_commands_defs.h:1997
cryptonote::COMMAND_RPC_SETBANS::response_t
Definition: core_rpc_server_commands_defs.h:2007
cryptonote::COMMAND_RPC_SETBANS
Definition: core_rpc_server_commands_defs.h:1979
cryptonote::COMMAND_RPC_SETBANS::response
epee::misc_utils::struct_init< response_t > response
Definition: core_rpc_server_commands_defs.h:2012
cryptonote::COMMAND_RPC_SET_BOOTSTRAP_DAEMON::request_t
Definition: core_rpc_server_commands_defs.h:1734
cryptonote::COMMAND_RPC_SET_BOOTSTRAP_DAEMON::request_t::username
std::string username
Definition: core_rpc_server_commands_defs.h:1736
cryptonote::COMMAND_RPC_SET_BOOTSTRAP_DAEMON::request_t::password
std::string password
Definition: core_rpc_server_commands_defs.h:1737
cryptonote::COMMAND_RPC_SET_BOOTSTRAP_DAEMON::request_t::address
std::string address
Definition: core_rpc_server_commands_defs.h:1735
cryptonote::COMMAND_RPC_SET_BOOTSTRAP_DAEMON::request_t::proxy
std::string proxy
Definition: core_rpc_server_commands_defs.h:1738
cryptonote::COMMAND_RPC_SET_BOOTSTRAP_DAEMON::response_t
Definition: core_rpc_server_commands_defs.h:1750
cryptonote::COMMAND_RPC_SET_BOOTSTRAP_DAEMON::response_t::status
std::string status
Definition: core_rpc_server_commands_defs.h:1751
cryptonote::COMMAND_RPC_SET_BOOTSTRAP_DAEMON
Definition: core_rpc_server_commands_defs.h:1732
cryptonote::COMMAND_RPC_SET_LIMIT::request_t
Definition: core_rpc_server_commands_defs.h:1825
cryptonote::COMMAND_RPC_SET_LIMIT::request_t::limit_down
int64_t limit_down
Definition: core_rpc_server_commands_defs.h:1826
cryptonote::COMMAND_RPC_SET_LIMIT::request_t::limit_up
int64_t limit_up
Definition: core_rpc_server_commands_defs.h:1827
cryptonote::COMMAND_RPC_SET_LIMIT::response_t
Definition: core_rpc_server_commands_defs.h:1838
cryptonote::COMMAND_RPC_SET_LIMIT::response_t::limit_down
int64_t limit_down
Definition: core_rpc_server_commands_defs.h:1840
cryptonote::COMMAND_RPC_SET_LIMIT::response_t::limit_up
int64_t limit_up
Definition: core_rpc_server_commands_defs.h:1839
cryptonote::COMMAND_RPC_SET_LIMIT
Definition: core_rpc_server_commands_defs.h:1823
cryptonote::COMMAND_RPC_SET_LOG_CATEGORIES::request_t
Definition: core_rpc_server_commands_defs.h:1443
cryptonote::COMMAND_RPC_SET_LOG_CATEGORIES::request_t::categories
std::string categories
Definition: core_rpc_server_commands_defs.h:1444
cryptonote::COMMAND_RPC_SET_LOG_CATEGORIES::response_t
Definition: core_rpc_server_commands_defs.h:1454
cryptonote::COMMAND_RPC_SET_LOG_CATEGORIES::response_t::categories
std::string categories
Definition: core_rpc_server_commands_defs.h:1455
cryptonote::COMMAND_RPC_SET_LOG_CATEGORIES
Definition: core_rpc_server_commands_defs.h:1441
cryptonote::COMMAND_RPC_SET_LOG_HASH_RATE::request_t
Definition: core_rpc_server_commands_defs.h:1399
cryptonote::COMMAND_RPC_SET_LOG_HASH_RATE::request_t::visible
bool visible
Definition: core_rpc_server_commands_defs.h:1400
cryptonote::COMMAND_RPC_SET_LOG_HASH_RATE::response_t
Definition: core_rpc_server_commands_defs.h:1410
cryptonote::COMMAND_RPC_SET_LOG_HASH_RATE
Definition: core_rpc_server_commands_defs.h:1397
cryptonote::COMMAND_RPC_SET_LOG_HASH_RATE::response
epee::misc_utils::struct_init< response_t > response
Definition: core_rpc_server_commands_defs.h:1415
cryptonote::COMMAND_RPC_SET_LOG_LEVEL::request_t
Definition: core_rpc_server_commands_defs.h:1421
cryptonote::COMMAND_RPC_SET_LOG_LEVEL::request_t::level
int8_t level
Definition: core_rpc_server_commands_defs.h:1422
cryptonote::COMMAND_RPC_SET_LOG_LEVEL::response_t
Definition: core_rpc_server_commands_defs.h:1432
cryptonote::COMMAND_RPC_SET_LOG_LEVEL
Definition: core_rpc_server_commands_defs.h:1419
cryptonote::COMMAND_RPC_SET_LOG_LEVEL::response
epee::misc_utils::struct_init< response_t > response
Definition: core_rpc_server_commands_defs.h:1437
cryptonote::COMMAND_RPC_START_MINING::request_t
Definition: core_rpc_server_commands_defs.h:617
cryptonote::COMMAND_RPC_START_MINING::request_t::do_background_mining
bool do_background_mining
Definition: core_rpc_server_commands_defs.h:620
cryptonote::COMMAND_RPC_START_MINING::request_t::threads_count
uint64_t threads_count
Definition: core_rpc_server_commands_defs.h:619
cryptonote::COMMAND_RPC_START_MINING::request_t::miner_address
std::string miner_address
Definition: core_rpc_server_commands_defs.h:618
cryptonote::COMMAND_RPC_START_MINING::request_t::ignore_battery
bool ignore_battery
Definition: core_rpc_server_commands_defs.h:621
cryptonote::COMMAND_RPC_START_MINING::response_t
Definition: core_rpc_server_commands_defs.h:634
cryptonote::COMMAND_RPC_START_MINING
Definition: core_rpc_server_commands_defs.h:615
cryptonote::COMMAND_RPC_START_MINING::response
epee::misc_utils::struct_init< response_t > response
Definition: core_rpc_server_commands_defs.h:639
cryptonote::COMMAND_RPC_STOP_DAEMON::request_t
Definition: core_rpc_server_commands_defs.h:1763
cryptonote::COMMAND_RPC_STOP_DAEMON::response_t
Definition: core_rpc_server_commands_defs.h:1771
cryptonote::COMMAND_RPC_STOP_DAEMON
Definition: core_rpc_server_commands_defs.h:1761
cryptonote::COMMAND_RPC_STOP_DAEMON::response
epee::misc_utils::struct_init< response_t > response
Definition: core_rpc_server_commands_defs.h:1776
cryptonote::COMMAND_RPC_STOP_DAEMON::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:1768
cryptonote::COMMAND_RPC_STOP_MINING::request_t
Definition: core_rpc_server_commands_defs.h:777
cryptonote::COMMAND_RPC_STOP_MINING::response_t
Definition: core_rpc_server_commands_defs.h:786
cryptonote::COMMAND_RPC_STOP_MINING
Definition: core_rpc_server_commands_defs.h:775
cryptonote::COMMAND_RPC_STOP_MINING::response
epee::misc_utils::struct_init< response_t > response
Definition: core_rpc_server_commands_defs.h:791
cryptonote::COMMAND_RPC_STOP_MINING::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:782
cryptonote::COMMAND_RPC_SUBMITBLOCK::response_t
Definition: core_rpc_server_commands_defs.h:1068
cryptonote::COMMAND_RPC_SUBMITBLOCK
Definition: core_rpc_server_commands_defs.h:1064
cryptonote::COMMAND_RPC_SUBMITBLOCK::request
std::vector< std::string > request
Definition: core_rpc_server_commands_defs.h:1065
cryptonote::COMMAND_RPC_SUBMITBLOCK::response
epee::misc_utils::struct_init< response_t > response
Definition: core_rpc_server_commands_defs.h:1073
cryptonote::COMMAND_RPC_SUBMIT_RAW_TX::request_t
Definition: core_rpc_server_commands_defs.h:296
cryptonote::COMMAND_RPC_SUBMIT_RAW_TX::request_t::address
std::string address
Definition: core_rpc_server_commands_defs.h:297
cryptonote::COMMAND_RPC_SUBMIT_RAW_TX::request_t::tx
std::string tx
Definition: core_rpc_server_commands_defs.h:299
cryptonote::COMMAND_RPC_SUBMIT_RAW_TX::request_t::view_key
std::string view_key
Definition: core_rpc_server_commands_defs.h:298
cryptonote::COMMAND_RPC_SUBMIT_RAW_TX::response_t
Definition: core_rpc_server_commands_defs.h:311
cryptonote::COMMAND_RPC_SUBMIT_RAW_TX::response_t::status
std::string status
Definition: core_rpc_server_commands_defs.h:312
cryptonote::COMMAND_RPC_SUBMIT_RAW_TX::response_t::error
std::string error
Definition: core_rpc_server_commands_defs.h:313
cryptonote::COMMAND_RPC_SUBMIT_RAW_TX
Definition: core_rpc_server_commands_defs.h:294
cryptonote::COMMAND_RPC_SYNC_INFO::peer
Definition: core_rpc_server_commands_defs.h:2340
cryptonote::COMMAND_RPC_SYNC_INFO::peer::info
connection_info info
Definition: core_rpc_server_commands_defs.h:2341
cryptonote::COMMAND_RPC_SYNC_INFO::request_t
Definition: core_rpc_server_commands_defs.h:2332
cryptonote::COMMAND_RPC_SYNC_INFO::response_t
Definition: core_rpc_server_commands_defs.h:2370
cryptonote::COMMAND_RPC_SYNC_INFO::response_t::target_height
uint64_t target_height
Definition: core_rpc_server_commands_defs.h:2372
cryptonote::COMMAND_RPC_SYNC_INFO::response_t::peers
std::list< peer > peers
Definition: core_rpc_server_commands_defs.h:2374
cryptonote::COMMAND_RPC_SYNC_INFO::response_t::next_needed_pruning_seed
uint32_t next_needed_pruning_seed
Definition: core_rpc_server_commands_defs.h:2373
cryptonote::COMMAND_RPC_SYNC_INFO::response_t::height
uint64_t height
Definition: core_rpc_server_commands_defs.h:2371
cryptonote::COMMAND_RPC_SYNC_INFO::response_t::overview
std::string overview
Definition: core_rpc_server_commands_defs.h:2376
cryptonote::COMMAND_RPC_SYNC_INFO::response_t::spans
std::list< span > spans
Definition: core_rpc_server_commands_defs.h:2375
cryptonote::COMMAND_RPC_SYNC_INFO::span
Definition: core_rpc_server_commands_defs.h:2349
cryptonote::COMMAND_RPC_SYNC_INFO::span::remote_address
std::string remote_address
Definition: core_rpc_server_commands_defs.h:2356
cryptonote::COMMAND_RPC_SYNC_INFO::span::connection_id
std::string connection_id
Definition: core_rpc_server_commands_defs.h:2352
cryptonote::COMMAND_RPC_SYNC_INFO::span::size
uint64_t size
Definition: core_rpc_server_commands_defs.h:2355
cryptonote::COMMAND_RPC_SYNC_INFO::span::speed
uint32_t speed
Definition: core_rpc_server_commands_defs.h:2354
cryptonote::COMMAND_RPC_SYNC_INFO::span::rate
uint32_t rate
Definition: core_rpc_server_commands_defs.h:2353
cryptonote::COMMAND_RPC_SYNC_INFO::span::nblocks
uint64_t nblocks
Definition: core_rpc_server_commands_defs.h:2351
cryptonote::COMMAND_RPC_SYNC_INFO::span::start_block_height
uint64_t start_block_height
Definition: core_rpc_server_commands_defs.h:2350
cryptonote::COMMAND_RPC_SYNC_INFO
Definition: core_rpc_server_commands_defs.h:2330
cryptonote::COMMAND_RPC_SYNC_INFO::request
epee::misc_utils::struct_init< request_t > request
Definition: core_rpc_server_commands_defs.h:2337
cryptonote::COMMAND_RPC_UPDATE::request_t
Definition: core_rpc_server_commands_defs.h:2273
cryptonote::COMMAND_RPC_UPDATE::request_t::command
std::string command
Definition: core_rpc_server_commands_defs.h:2274
cryptonote::COMMAND_RPC_UPDATE::request_t::path
std::string path
Definition: core_rpc_server_commands_defs.h:2275
cryptonote::COMMAND_RPC_UPDATE::response_t
Definition: core_rpc_server_commands_defs.h:2286
cryptonote::COMMAND_RPC_UPDATE::response_t::hash
std::string hash
Definition: core_rpc_server_commands_defs.h:2291
cryptonote::COMMAND_RPC_UPDATE::response_t::user_uri
std::string user_uri
Definition: core_rpc_server_commands_defs.h:2289
cryptonote::COMMAND_RPC_UPDATE::response_t::path
std::string path
Definition: core_rpc_server_commands_defs.h:2292
cryptonote::COMMAND_RPC_UPDATE::response_t::auto_uri
std::string auto_uri
Definition: core_rpc_server_commands_defs.h:2290
cryptonote::COMMAND_RPC_UPDATE::response_t::update
bool update
Definition: core_rpc_server_commands_defs.h:2287
cryptonote::COMMAND_RPC_UPDATE::response_t::version
std::string version
Definition: core_rpc_server_commands_defs.h:2288
cryptonote::COMMAND_RPC_UPDATE
Definition: core_rpc_server_commands_defs.h:2271
cryptonote::block_header_response
Definition: core_rpc_server_commands_defs.h:1110
cryptonote::block_header_response::minor_version
uint8_t minor_version
Definition: core_rpc_server_commands_defs.h:1112
cryptonote::block_header_response::difficulty_top64
uint64_t difficulty_top64
Definition: core_rpc_server_commands_defs.h:1122
cryptonote::block_header_response::reward
uint64_t reward
Definition: core_rpc_server_commands_defs.h:1126
cryptonote::block_header_response::timestamp
uint64_t timestamp
Definition: core_rpc_server_commands_defs.h:1113
cryptonote::block_header_response::pow_hash
std::string pow_hash
Definition: core_rpc_server_commands_defs.h:1130
cryptonote::block_header_response::major_version
uint8_t major_version
Definition: core_rpc_server_commands_defs.h:1111
cryptonote::block_header_response::difficulty
uint64_t difficulty
Definition: core_rpc_server_commands_defs.h:1120
cryptonote::block_header_response::miner_tx_hash
std::string miner_tx_hash
Definition: core_rpc_server_commands_defs.h:1132
cryptonote::block_header_response::nonce
uint32_t nonce
Definition: core_rpc_server_commands_defs.h:1115
cryptonote::block_header_response::hash
std::string hash
Definition: core_rpc_server_commands_defs.h:1119
cryptonote::block_header_response::orphan_status
bool orphan_status
Definition: core_rpc_server_commands_defs.h:1116
cryptonote::block_header_response::long_term_weight
uint64_t long_term_weight
Definition: core_rpc_server_commands_defs.h:1131
cryptonote::block_header_response::block_size
uint64_t block_size
Definition: core_rpc_server_commands_defs.h:1127
cryptonote::block_header_response::cumulative_difficulty
uint64_t cumulative_difficulty
Definition: core_rpc_server_commands_defs.h:1123
cryptonote::block_header_response::cumulative_difficulty_top64
uint64_t cumulative_difficulty_top64
Definition: core_rpc_server_commands_defs.h:1125
cryptonote::block_header_response::height
uint64_t height
Definition: core_rpc_server_commands_defs.h:1117
cryptonote::block_header_response::wide_difficulty
std::string wide_difficulty
Definition: core_rpc_server_commands_defs.h:1121
cryptonote::block_header_response::num_txes
uint64_t num_txes
Definition: core_rpc_server_commands_defs.h:1129
cryptonote::block_header_response::depth
uint64_t depth
Definition: core_rpc_server_commands_defs.h:1118
cryptonote::block_header_response::block_weight
uint64_t block_weight
Definition: core_rpc_server_commands_defs.h:1128
cryptonote::block_header_response::prev_hash
std::string prev_hash
Definition: core_rpc_server_commands_defs.h:1114
cryptonote::block_header_response::wide_cumulative_difficulty
std::string wide_cumulative_difficulty
Definition: core_rpc_server_commands_defs.h:1124
cryptonote::block_header
Definition: cryptonote_basic.h:458
cryptonote::connection_info
Definition: cryptonote_protocol_defs.h:48
cryptonote::get_outputs_out
Definition: core_rpc_server_commands_defs.h:466
cryptonote::get_outputs_out::amount
uint64_t amount
Definition: core_rpc_server_commands_defs.h:467
cryptonote::get_outputs_out::index
uint64_t index
Definition: core_rpc_server_commands_defs.h:468
cryptonote::peer
Definition: core_rpc_server_commands_defs.h:1281
cryptonote::peer::ip
uint32_t ip
Definition: core_rpc_server_commands_defs.h:1284
cryptonote::peer::pruning_seed
uint32_t pruning_seed
Definition: core_rpc_server_commands_defs.h:1289
cryptonote::peer::rpc_credits_per_hash
uint32_t rpc_credits_per_hash
Definition: core_rpc_server_commands_defs.h:1287
cryptonote::peer::last_seen
uint64_t last_seen
Definition: core_rpc_server_commands_defs.h:1288
cryptonote::peer::peer
peer(uint64_t id, uint32_t ip, uint16_t port, uint64_t last_seen, uint32_t pruning_seed, uint16_t rpc_port, uint32_t rpc_credits_per_hash)
Definition: core_rpc_server_commands_defs.h:1299
cryptonote::peer::peer
peer(uint64_t id, const std::string &host, uint16_t port, uint64_t last_seen, uint32_t pruning_seed, uint16_t rpc_port, uint32_t rpc_credits_per_hash)
Definition: core_rpc_server_commands_defs.h:1296
cryptonote::peer::port
uint16_t port
Definition: core_rpc_server_commands_defs.h:1285
cryptonote::peer::host
std::string host
Definition: core_rpc_server_commands_defs.h:1283
cryptonote::peer::rpc_port
uint16_t rpc_port
Definition: core_rpc_server_commands_defs.h:1286
cryptonote::peer::id
uint64_t id
Definition: core_rpc_server_commands_defs.h:1282
cryptonote::peer::peer
peer(uint64_t id, const std::string &host, uint64_t last_seen, uint32_t pruning_seed, uint16_t rpc_port, uint32_t rpc_credits_per_hash)
Definition: core_rpc_server_commands_defs.h:1293
cryptonote::public_node
Definition: core_rpc_server_commands_defs.h:1345
cryptonote::public_node::host
std::string host
Definition: core_rpc_server_commands_defs.h:1346
cryptonote::public_node::last_seen
uint64_t last_seen
Definition: core_rpc_server_commands_defs.h:1347
cryptonote::public_node::rpc_credits_per_hash
uint32_t rpc_credits_per_hash
Definition: core_rpc_server_commands_defs.h:1349
cryptonote::public_node::public_node
public_node()
Definition: core_rpc_server_commands_defs.h:1351
cryptonote::public_node::public_node
public_node(const peer &peer)
Definition: core_rpc_server_commands_defs.h:1353
cryptonote::public_node::rpc_port
uint16_t rpc_port
Definition: core_rpc_server_commands_defs.h:1348
cryptonote::rpc::output_distribution_data
Definition: rpc_handler.h:46
cryptonote::rpc_access_request_base
Definition: core_rpc_server_commands_defs.h:115
cryptonote::rpc_access_request_base::client
std::string client
Definition: core_rpc_server_commands_defs.h:116
cryptonote::rpc_access_response_base
Definition: core_rpc_server_commands_defs.h:125
cryptonote::rpc_access_response_base::credits
uint64_t credits
Definition: core_rpc_server_commands_defs.h:126
cryptonote::rpc_access_response_base::top_hash
std::string top_hash
Definition: core_rpc_server_commands_defs.h:127
cryptonote::rpc_access_response_base::rpc_access_response_base
rpc_access_response_base()
Definition: core_rpc_server_commands_defs.h:129
cryptonote::rpc_request_base
Definition: core_rpc_server_commands_defs.h:96
cryptonote::rpc_response_base
Definition: core_rpc_server_commands_defs.h:102
cryptonote::rpc_response_base::status
std::string status
Definition: core_rpc_server_commands_defs.h:103
cryptonote::rpc_response_base::untrusted
bool untrusted
Definition: core_rpc_server_commands_defs.h:104
cryptonote::rpc_response_base::rpc_response_base
rpc_response_base()
Definition: core_rpc_server_commands_defs.h:106
cryptonote::spent_key_image_info
Definition: core_rpc_server_commands_defs.h:1505
cryptonote::spent_key_image_info::id_hash
std::string id_hash
Definition: core_rpc_server_commands_defs.h:1506
cryptonote::spent_key_image_info::txs_hashes
std::vector< std::string > txs_hashes
Definition: core_rpc_server_commands_defs.h:1507
cryptonote::tx_backlog_entry
Definition: core_rpc_server_commands_defs.h:1584
cryptonote::tx_backlog_entry::weight
uint64_t weight
Definition: core_rpc_server_commands_defs.h:1585
cryptonote::tx_backlog_entry::fee
uint64_t fee
Definition: core_rpc_server_commands_defs.h:1586
cryptonote::tx_backlog_entry::time_in_pool
uint64_t time_in_pool
Definition: core_rpc_server_commands_defs.h:1587
cryptonote::tx_info
Definition: core_rpc_server_commands_defs.h:1466
cryptonote::tx_info::max_used_block_id_hash
std::string max_used_block_id_hash
Definition: core_rpc_server_commands_defs.h:1472
cryptonote::tx_info::max_used_block_height
uint64_t max_used_block_height
Definition: core_rpc_server_commands_defs.h:1473
cryptonote::tx_info::blob_size
uint64_t blob_size
Definition: core_rpc_server_commands_defs.h:1469
cryptonote::tx_info::relayed
bool relayed
Definition: core_rpc_server_commands_defs.h:1478
cryptonote::tx_info::last_failed_height
uint64_t last_failed_height
Definition: core_rpc_server_commands_defs.h:1475
cryptonote::tx_info::do_not_relay
bool do_not_relay
Definition: core_rpc_server_commands_defs.h:1480
cryptonote::tx_info::receive_time
uint64_t receive_time
Definition: core_rpc_server_commands_defs.h:1477
cryptonote::tx_info::kept_by_block
bool kept_by_block
Definition: core_rpc_server_commands_defs.h:1474
cryptonote::tx_info::tx_json
std::string tx_json
Definition: core_rpc_server_commands_defs.h:1468
cryptonote::tx_info::fee
uint64_t fee
Definition: core_rpc_server_commands_defs.h:1471
cryptonote::tx_info::last_failed_id_hash
std::string last_failed_id_hash
Definition: core_rpc_server_commands_defs.h:1476
cryptonote::tx_info::last_relayed_time
uint64_t last_relayed_time
Definition: core_rpc_server_commands_defs.h:1479
cryptonote::tx_info::weight
uint64_t weight
Definition: core_rpc_server_commands_defs.h:1470
cryptonote::tx_info::tx_blob
std::string tx_blob
Definition: core_rpc_server_commands_defs.h:1482
cryptonote::tx_info::id_hash
std::string id_hash
Definition: core_rpc_server_commands_defs.h:1467
cryptonote::tx_info::double_spend_seen
bool double_spend_seen
Definition: core_rpc_server_commands_defs.h:1481
cryptonote::txpool_histo
Definition: core_rpc_server_commands_defs.h:1613
cryptonote::txpool_histo::bytes
uint64_t bytes
Definition: core_rpc_server_commands_defs.h:1615
cryptonote::txpool_histo::txs
uint32_t txs
Definition: core_rpc_server_commands_defs.h:1614
cryptonote::txpool_stats
Definition: core_rpc_server_commands_defs.h:1624
cryptonote::txpool_stats::oldest
uint64_t oldest
Definition: core_rpc_server_commands_defs.h:1630
cryptonote::txpool_stats::num_not_relayed
uint32_t num_not_relayed
Definition: core_rpc_server_commands_defs.h:1634
cryptonote::txpool_stats::num_10m
uint32_t num_10m
Definition: core_rpc_server_commands_defs.h:1633
cryptonote::txpool_stats::num_double_spends
uint32_t num_double_spends
Definition: core_rpc_server_commands_defs.h:1637
cryptonote::txpool_stats::txpool_stats
txpool_stats()
Definition: core_rpc_server_commands_defs.h:1639
cryptonote::txpool_stats::bytes_total
uint64_t bytes_total
Definition: core_rpc_server_commands_defs.h:1625
cryptonote::txpool_stats::histo
std::vector< txpool_histo > histo
Definition: core_rpc_server_commands_defs.h:1636
cryptonote::txpool_stats::histo_98pc
uint64_t histo_98pc
Definition: core_rpc_server_commands_defs.h:1635
cryptonote::txpool_stats::txs_total
uint32_t txs_total
Definition: core_rpc_server_commands_defs.h:1631
cryptonote::txpool_stats::num_failing
uint32_t num_failing
Definition: core_rpc_server_commands_defs.h:1632
cryptonote::txpool_stats::fee_total
uint64_t fee_total
Definition: core_rpc_server_commands_defs.h:1629
cryptonote::txpool_stats::bytes_max
uint32_t bytes_max
Definition: core_rpc_server_commands_defs.h:1627
cryptonote::txpool_stats::bytes_min
uint32_t bytes_min
Definition: core_rpc_server_commands_defs.h:1626
cryptonote::txpool_stats::bytes_med
uint32_t bytes_med
Definition: core_rpc_server_commands_defs.h:1628
epee::misc_utils::struct_init
Definition: misc_language.h:104
rct::key
Definition: rctTypes.h:79
state
Definition: blake256.h:36
data
std::string data
Definition: base58.cpp:37
hashes
struct hash_func hashes[]
tx
cryptonote::transaction tx
Definition: transaction.cpp:40
json
rapidjson::Document json
Definition: transport.cpp:50
varint.h
provides the implementation of varint's
T
#define T(x)
Generated on Sat Feb 18 2023 00:00:00 for Monero by doxygen 1.9.6