Electroneum
core_rpc_server_commands_defs.h
Go to the documentation of this file.
1 // Copyrights(c) 2017-2018, The Electroneum Project
2 // Copyrights(c) 2014-2017, The Monero Project
3 //
4 // All rights reserved.
5 //
6 // Redistribution and use in source and binary forms, with or without modification, are
7 // permitted provided that the following conditions are met:
8 //
9 // 1. Redistributions of source code must retain the above copyright notice, this list of
10 // conditions and the following disclaimer.
11 //
12 // 2. Redistributions in binary form must reproduce the above copyright notice, this list
13 // of conditions and the following disclaimer in the documentation and/or other
14 // materials provided with the distribution.
15 //
16 // 3. Neither the name of the copyright holder nor the names of its contributors may be
17 // used to endorse or promote products derived from this software without specific
18 // prior written permission.
19 //
20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
21 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
22 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
23 // THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
27 // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
28 // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 //
30 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
31 
32 #pragma once
36 #include "crypto/hash.h"
37 
38 namespace cryptonote
39 {
40  //-----------------------------------------------
41 #define CORE_RPC_STATUS_OK "OK"
42 #define CORE_RPC_STATUS_BUSY "BUSY"
43 #define CORE_RPC_STATUS_NOT_MINING "NOT MINING"
44 
45 // When making *any* change here, bump minor
46 // If the change is incompatible, then bump major and set minor to 0
47 // This ensures CORE_RPC_VERSION always increases, that every change
48 // has its own version, and that clients can just test major to see
49 // whether they can talk to a given daemon without having to know in
50 // advance which version they will stop working with
51 // Don't go over 32767 for any of these
52 #define CORE_RPC_VERSION_MAJOR 1
53 #define CORE_RPC_VERSION_MINOR 13
54 #define MAKE_CORE_RPC_VERSION(major,minor) (((major)<<16)|(minor))
55 #define CORE_RPC_VERSION MAKE_CORE_RPC_VERSION(CORE_RPC_VERSION_MAJOR, CORE_RPC_VERSION_MINOR)
56 
58  {
59  struct request
60  {
61  BEGIN_KV_SERIALIZE_MAP()
62  END_KV_SERIALIZE_MAP()
63  };
64 
65  struct response
66  {
67  uint64_t height;
68  std::string status;
69 
70  BEGIN_KV_SERIALIZE_MAP()
71  KV_SERIALIZE(height)
72  KV_SERIALIZE(status)
73  END_KV_SERIALIZE_MAP()
74  };
75  };
76 
78  {
79 
80  struct request
81  {
82  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 */
83  uint64_t start_height;
84  bool prune;
85  BEGIN_KV_SERIALIZE_MAP()
86  KV_SERIALIZE_CONTAINER_POD_AS_BLOB(block_ids)
87  KV_SERIALIZE(start_height)
88  KV_SERIALIZE(prune)
89  END_KV_SERIALIZE_MAP()
90  };
91 
93  {
94  std::vector<uint64_t> indices;
95 
96  BEGIN_KV_SERIALIZE_MAP()
97  KV_SERIALIZE(indices)
98  END_KV_SERIALIZE_MAP()
99  };
100 
102  {
103  std::vector<tx_output_indices> indices;
104 
105  BEGIN_KV_SERIALIZE_MAP()
106  KV_SERIALIZE(indices)
107  END_KV_SERIALIZE_MAP()
108  };
109 
110  struct response
111  {
112  std::list<block_complete_entry> blocks;
113  uint64_t start_height;
114  uint64_t current_height;
115  std::string status;
116  std::vector<block_output_indices> output_indices;
117 
118  BEGIN_KV_SERIALIZE_MAP()
119  KV_SERIALIZE(blocks)
120  KV_SERIALIZE(start_height)
121  KV_SERIALIZE(current_height)
122  KV_SERIALIZE(status)
123  KV_SERIALIZE(output_indices)
124  END_KV_SERIALIZE_MAP()
125  };
126  };
127 
129  {
130  struct request
131  {
132  std::vector<uint64_t> heights;
133  BEGIN_KV_SERIALIZE_MAP()
134  KV_SERIALIZE(heights)
135  END_KV_SERIALIZE_MAP()
136  };
137 
138  struct response
139  {
140  std::vector<block_complete_entry> blocks;
141  std::string status;
142 
143  BEGIN_KV_SERIALIZE_MAP()
144  KV_SERIALIZE(blocks)
145  KV_SERIALIZE(status)
146  END_KV_SERIALIZE_MAP()
147  };
148  };
149 
151  {
152  struct request
153  {
154  BEGIN_KV_SERIALIZE_MAP()
155  END_KV_SERIALIZE_MAP()
156  };
157 
158  struct response
159  {
160  std::vector<std::string> blks_hashes;
161  std::string status;
162 
163  BEGIN_KV_SERIALIZE_MAP()
164  KV_SERIALIZE(blks_hashes)
165  KV_SERIALIZE(status)
166  END_KV_SERIALIZE_MAP()
167  };
168  };
170  {
171 
172  struct request
173  {
174  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 */
175  uint64_t start_height;
176  BEGIN_KV_SERIALIZE_MAP()
177  KV_SERIALIZE_CONTAINER_POD_AS_BLOB(block_ids)
178  KV_SERIALIZE(start_height)
179  END_KV_SERIALIZE_MAP()
180  };
181 
182  struct response
183  {
184  std::list<crypto::hash> m_block_ids;
185  uint64_t start_height;
186  uint64_t current_height;
187  std::string status;
188 
189  BEGIN_KV_SERIALIZE_MAP()
190  KV_SERIALIZE_CONTAINER_POD_AS_BLOB(m_block_ids)
191  KV_SERIALIZE(start_height)
192  KV_SERIALIZE(current_height)
193  KV_SERIALIZE(status)
194  END_KV_SERIALIZE_MAP()
195  };
196  };
197 
198  //-----------------------------------------------
200  {
201  struct request
202  {
203  std::list<std::string> txs_hashes;
205 
206  BEGIN_KV_SERIALIZE_MAP()
207  KV_SERIALIZE(txs_hashes)
208  KV_SERIALIZE(decode_as_json)
209  END_KV_SERIALIZE_MAP()
210  };
211 
212  struct entry
213  {
214  std::string tx_hash;
215  std::string as_hex;
216  std::string as_json;
217  bool in_pool;
218  uint64_t block_height;
219  std::vector<uint64_t> output_indices;
220 
221  BEGIN_KV_SERIALIZE_MAP()
222  KV_SERIALIZE(tx_hash)
223  KV_SERIALIZE(as_hex)
224  KV_SERIALIZE(as_json)
225  KV_SERIALIZE(in_pool)
226  KV_SERIALIZE(block_height)
227  KV_SERIALIZE(output_indices)
228  END_KV_SERIALIZE_MAP()
229  };
230 
231  struct response
232  {
233  // older compatibility stuff
234  std::list<std::string> txs_as_hex; //transactions blobs as hex (old compat)
235  std::list<std::string> txs_as_json; //transactions decoded as json (old compat)
236 
237  // in both old and new
238  std::list<std::string> missed_tx; //not found transactions
239 
240  // new style
241  std::vector<entry> txs;
242  std::string status;
243 
244  BEGIN_KV_SERIALIZE_MAP()
245  KV_SERIALIZE(txs_as_hex)
246  KV_SERIALIZE(txs_as_json)
247  KV_SERIALIZE(txs)
248  KV_SERIALIZE(missed_tx)
249  KV_SERIALIZE(status)
250  END_KV_SERIALIZE_MAP()
251  };
252  };
253 
254  //-----------------------------------------------
256  {
257  enum STATUS {
258  UNSPENT = 0,
259  SPENT_IN_BLOCKCHAIN = 1,
260  SPENT_IN_POOL = 2,
261  };
262 
263  struct request
264  {
265  std::vector<std::string> key_images;
266 
267  BEGIN_KV_SERIALIZE_MAP()
268  KV_SERIALIZE(key_images)
269  END_KV_SERIALIZE_MAP()
270  };
271 
272 
273  struct response
274  {
275  std::vector<int> spent_status;
276  std::string status;
277 
278  BEGIN_KV_SERIALIZE_MAP()
279  KV_SERIALIZE(spent_status)
280  KV_SERIALIZE(status)
281  END_KV_SERIALIZE_MAP()
282  };
283  };
284 
285  //-----------------------------------------------
287  {
288  struct request
289  {
291  BEGIN_KV_SERIALIZE_MAP()
292  KV_SERIALIZE_VAL_POD_AS_BLOB(txid)
293  END_KV_SERIALIZE_MAP()
294  };
295 
296 
297  struct response
298  {
299  std::vector<uint64_t> o_indexes;
300  std::string status;
301  BEGIN_KV_SERIALIZE_MAP()
302  KV_SERIALIZE(o_indexes)
303  KV_SERIALIZE(status)
304  END_KV_SERIALIZE_MAP()
305  };
306  };
307  //-----------------------------------------------
309  {
310  struct request
311  {
312  std::vector<uint64_t> amounts;
313  uint64_t outs_count;
314  BEGIN_KV_SERIALIZE_MAP()
315  KV_SERIALIZE(amounts)
316  KV_SERIALIZE(outs_count)
317  END_KV_SERIALIZE_MAP()
318  };
319 
320 #pragma pack (push, 1)
321  struct out_entry
322  {
325  };
326 #pragma pack(pop)
327 
329  {
330  uint64_t amount;
331  std::list<out_entry> outs;
332 
333  BEGIN_KV_SERIALIZE_MAP()
334  KV_SERIALIZE(amount)
335  KV_SERIALIZE_CONTAINER_POD_AS_BLOB(outs)
336  END_KV_SERIALIZE_MAP()
337  };
338 
339  struct response
340  {
341  std::vector<outs_for_amount> outs;
342  std::string status;
343  BEGIN_KV_SERIALIZE_MAP()
344  KV_SERIALIZE(outs)
345  KV_SERIALIZE(status)
346  END_KV_SERIALIZE_MAP()
347  };
348  };
349  //-----------------------------------------------
351  {
352  uint64_t amount;
353  uint64_t index;
354 
355  BEGIN_KV_SERIALIZE_MAP()
356  KV_SERIALIZE(amount)
357  KV_SERIALIZE(index)
358  END_KV_SERIALIZE_MAP()
359  };
360 
362  {
363  struct request
364  {
365  std::vector<get_outputs_out> outputs;
366 
367  BEGIN_KV_SERIALIZE_MAP()
368  KV_SERIALIZE(outputs)
369  END_KV_SERIALIZE_MAP()
370  };
371 
372  struct outkey
373  {
376  bool unlocked;
377  uint64_t height;
379 
380  BEGIN_KV_SERIALIZE_MAP()
381  KV_SERIALIZE_VAL_POD_AS_BLOB(key)
382  KV_SERIALIZE_VAL_POD_AS_BLOB(mask)
383  KV_SERIALIZE(unlocked)
384  KV_SERIALIZE(height)
385  KV_SERIALIZE_VAL_POD_AS_BLOB(txid)
386  END_KV_SERIALIZE_MAP()
387  };
388 
389  struct response
390  {
391  std::vector<outkey> outs;
392  std::string status;
393 
394  BEGIN_KV_SERIALIZE_MAP()
395  KV_SERIALIZE(outs)
396  KV_SERIALIZE(status)
397  END_KV_SERIALIZE_MAP()
398  };
399  };
400  //-----------------------------------------------
402  {
403  struct request
404  {
405  std::vector<get_outputs_out> outputs;
406 
407  BEGIN_KV_SERIALIZE_MAP()
408  KV_SERIALIZE(outputs)
409  END_KV_SERIALIZE_MAP()
410  };
411 
412  struct outkey
413  {
414  std::string key;
415  std::string mask;
416  bool unlocked;
417  uint64_t height;
418  std::string txid;
419 
420  BEGIN_KV_SERIALIZE_MAP()
421  KV_SERIALIZE(key)
422  KV_SERIALIZE(mask)
423  KV_SERIALIZE(unlocked)
424  KV_SERIALIZE(height)
425  KV_SERIALIZE(txid)
426  END_KV_SERIALIZE_MAP()
427  };
428 
429  struct response
430  {
431  std::vector<outkey> outs;
432  std::string status;
433 
434  BEGIN_KV_SERIALIZE_MAP()
435  KV_SERIALIZE(outs)
436  KV_SERIALIZE(status)
437  END_KV_SERIALIZE_MAP()
438  };
439  };
440 
442  {
443  struct request
444  {
445  uint64_t outs_count;
446  BEGIN_KV_SERIALIZE_MAP()
447  KV_SERIALIZE(outs_count)
448  END_KV_SERIALIZE_MAP()
449  };
450 
451 #pragma pack (push, 1)
452  struct out_entry
453  {
454  uint64_t amount;
458  };
459 #pragma pack(pop)
460 
461  struct response
462  {
463  std::list<out_entry> outs;
464  std::string status;
465  BEGIN_KV_SERIALIZE_MAP()
466  KV_SERIALIZE_CONTAINER_POD_AS_BLOB(outs)
467  KV_SERIALIZE(status)
468  END_KV_SERIALIZE_MAP()
469  };
470  };
471  //-----------------------------------------------
473  {
474  struct request
475  {
476  std::string tx_as_hex;
478 
479  request() {}
480  explicit request(const transaction &);
481 
482  BEGIN_KV_SERIALIZE_MAP()
483  KV_SERIALIZE(tx_as_hex)
484  KV_SERIALIZE(do_not_relay)
485  END_KV_SERIALIZE_MAP()
486  };
487 
488 
489  struct response
490  {
491  std::string status;
492  std::string reason;
494  bool low_mixin;
498  bool too_big;
499  bool overspend;
501  bool not_rct;
502 
503  BEGIN_KV_SERIALIZE_MAP()
504  KV_SERIALIZE(status)
505  KV_SERIALIZE(reason)
506  KV_SERIALIZE(not_relayed)
507  KV_SERIALIZE(low_mixin)
508  KV_SERIALIZE(double_spend)
509  KV_SERIALIZE(invalid_input)
510  KV_SERIALIZE(invalid_output)
511  KV_SERIALIZE(too_big)
512  KV_SERIALIZE(overspend)
513  KV_SERIALIZE(fee_too_low)
514  KV_SERIALIZE(not_rct)
515  END_KV_SERIALIZE_MAP()
516  };
517  };
518  //-----------------------------------------------
520  {
521  struct request
522  {
523  std::string miner_address;
524  uint64_t threads_count;
527 
528  BEGIN_KV_SERIALIZE_MAP()
529  KV_SERIALIZE(miner_address)
530  KV_SERIALIZE(threads_count)
531  KV_SERIALIZE(do_background_mining)
532  KV_SERIALIZE(ignore_battery)
533  END_KV_SERIALIZE_MAP()
534  };
535 
536  struct response
537  {
538  std::string status;
539 
540  BEGIN_KV_SERIALIZE_MAP()
541  KV_SERIALIZE(status)
542  END_KV_SERIALIZE_MAP()
543  };
544  };
545  //-----------------------------------------------
547  {
548  struct request
549  {
550 
551  BEGIN_KV_SERIALIZE_MAP()
552  END_KV_SERIALIZE_MAP()
553  };
554 
555  struct response
556  {
557  std::string status;
558  uint64_t height;
559  uint64_t target_height;
560  uint64_t difficulty;
561  uint64_t target;
562  uint64_t tx_count;
563  uint64_t tx_pool_size;
569  bool testnet;
570  std::string top_block_hash;
573  uint64_t start_time;
574 
575  BEGIN_KV_SERIALIZE_MAP()
576  KV_SERIALIZE(status)
577  KV_SERIALIZE(height)
578  KV_SERIALIZE(target_height)
579  KV_SERIALIZE(difficulty)
580  KV_SERIALIZE(target)
581  KV_SERIALIZE(tx_count)
582  KV_SERIALIZE(tx_pool_size)
583  KV_SERIALIZE(alt_blocks_count)
584  KV_SERIALIZE(outgoing_connections_count)
585  KV_SERIALIZE(incoming_connections_count)
586  KV_SERIALIZE(white_peerlist_size)
587  KV_SERIALIZE(grey_peerlist_size)
588  KV_SERIALIZE(testnet)
589  KV_SERIALIZE(top_block_hash)
590  KV_SERIALIZE(cumulative_difficulty)
591  KV_SERIALIZE(block_size_limit)
592  KV_SERIALIZE(start_time)
593  END_KV_SERIALIZE_MAP()
594  };
595  };
596 
597 
598  //-----------------------------------------------
600  {
601  struct request
602  {
603 
604  BEGIN_KV_SERIALIZE_MAP()
605  END_KV_SERIALIZE_MAP()
606  };
607 
608 
609  struct response
610  {
611  std::string status;
612 
613  BEGIN_KV_SERIALIZE_MAP()
614  KV_SERIALIZE(status)
615  END_KV_SERIALIZE_MAP()
616  };
617  };
618 
619  //-----------------------------------------------
621  {
622  struct request
623  {
624 
625  BEGIN_KV_SERIALIZE_MAP()
626  END_KV_SERIALIZE_MAP()
627  };
628 
629 
630  struct response
631  {
632  std::string status;
633  bool active;
634  uint64_t speed;
635  uint32_t threads_count;
636  std::string address;
638 
639  BEGIN_KV_SERIALIZE_MAP()
640  KV_SERIALIZE(status)
641  KV_SERIALIZE(active)
642  KV_SERIALIZE(speed)
643  KV_SERIALIZE(threads_count)
644  KV_SERIALIZE(address)
645  KV_SERIALIZE(is_background_mining_enabled)
646  END_KV_SERIALIZE_MAP()
647  };
648  };
649 
650  //-----------------------------------------------
652  {
653  struct request
654  {
655 
656  BEGIN_KV_SERIALIZE_MAP()
657  END_KV_SERIALIZE_MAP()
658  };
659 
660 
661  struct response
662  {
663  std::string status;
664 
665  BEGIN_KV_SERIALIZE_MAP()
666  KV_SERIALIZE(status)
667  END_KV_SERIALIZE_MAP()
668  };
669  };
670 
671  //
673  {
674  typedef std::list<std::string> request;
675 
676  struct response
677  {
678  uint64_t count;
679  std::string status;
680 
681  BEGIN_KV_SERIALIZE_MAP()
682  KV_SERIALIZE(count)
683  KV_SERIALIZE(status)
684  END_KV_SERIALIZE_MAP()
685  };
686 
687  };
688 
690  {
691  typedef std::vector<uint64_t> request;
692 
693  typedef std::string response;
694  };
695 
696 
698  {
699  struct request
700  {
701  uint64_t reserve_size; //max 255 bytes
702  std::string wallet_address;
703 
704  BEGIN_KV_SERIALIZE_MAP()
705  KV_SERIALIZE(reserve_size)
706  KV_SERIALIZE(wallet_address)
707  END_KV_SERIALIZE_MAP()
708  };
709 
710  struct response
711  {
712  uint64_t difficulty;
713  uint64_t height;
714  uint64_t reserved_offset;
715  uint64_t expected_reward;
716  std::string prev_hash;
719  std::string status;
720 
721  BEGIN_KV_SERIALIZE_MAP()
722  KV_SERIALIZE(difficulty)
723  KV_SERIALIZE(height)
724  KV_SERIALIZE(reserved_offset)
725  KV_SERIALIZE(expected_reward)
726  KV_SERIALIZE(prev_hash)
727  KV_SERIALIZE(blocktemplate_blob)
728  KV_SERIALIZE(blockhashing_blob)
729  KV_SERIALIZE(status)
730  END_KV_SERIALIZE_MAP()
731  };
732  };
733 
735  {
736  typedef std::vector<std::string> request;
737 
738  struct response
739  {
740  std::string status;
741 
742  BEGIN_KV_SERIALIZE_MAP()
743  KV_SERIALIZE(status)
744  END_KV_SERIALIZE_MAP()
745  };
746  };
747 
749  {
750  uint8_t major_version;
751  uint8_t minor_version;
752  uint64_t timestamp;
753  std::string prev_hash;
754  uint32_t nonce;
756  uint64_t height;
757  uint64_t depth;
758  std::string hash;
760  uint64_t reward;
761  uint64_t block_size;
762  uint64_t num_txes;
763 
764  BEGIN_KV_SERIALIZE_MAP()
765  KV_SERIALIZE(major_version)
766  KV_SERIALIZE(minor_version)
767  KV_SERIALIZE(timestamp)
768  KV_SERIALIZE(prev_hash)
769  KV_SERIALIZE(nonce)
770  KV_SERIALIZE(orphan_status)
771  KV_SERIALIZE(height)
772  KV_SERIALIZE(depth)
773  KV_SERIALIZE(hash)
774  KV_SERIALIZE(difficulty)
775  KV_SERIALIZE(reward)
776  KV_SERIALIZE(block_size)
777  KV_SERIALIZE(num_txes)
778  END_KV_SERIALIZE_MAP()
779  };
780 
782  {
783  struct request
784  {
785  BEGIN_KV_SERIALIZE_MAP()
786  END_KV_SERIALIZE_MAP()
787  };
788 
789  struct response
790  {
791  std::string status;
793 
794  BEGIN_KV_SERIALIZE_MAP()
795  KV_SERIALIZE(block_header)
796  KV_SERIALIZE(status)
797  END_KV_SERIALIZE_MAP()
798  };
799 
800  };
801 
803  {
804  struct request
805  {
806  std::string hash;
807 
808  BEGIN_KV_SERIALIZE_MAP()
809  KV_SERIALIZE(hash)
810  END_KV_SERIALIZE_MAP()
811  };
812 
813  struct response
814  {
815  std::string status;
817 
818  BEGIN_KV_SERIALIZE_MAP()
819  KV_SERIALIZE(block_header)
820  KV_SERIALIZE(status)
821  END_KV_SERIALIZE_MAP()
822  };
823 
824  };
825 
827  {
828  struct request
829  {
830  uint64_t height;
831 
832  BEGIN_KV_SERIALIZE_MAP()
833  KV_SERIALIZE(height)
834  END_KV_SERIALIZE_MAP()
835  };
836 
837  struct response
838  {
839  std::string status;
841 
842  BEGIN_KV_SERIALIZE_MAP()
843  KV_SERIALIZE(block_header)
844  KV_SERIALIZE(status)
845  END_KV_SERIALIZE_MAP()
846  };
847 
848  };
849 
851  {
852  struct request
853  {
854  std::string hash;
855  uint64_t height;
856 
857  BEGIN_KV_SERIALIZE_MAP()
858  KV_SERIALIZE(hash)
859  KV_SERIALIZE(height)
860  END_KV_SERIALIZE_MAP()
861  };
862 
863  struct response
864  {
865  std::string status;
867  std::vector<std::string> tx_hashes;
868  std::string blob;
869  std::string json;
870 
871  BEGIN_KV_SERIALIZE_MAP()
872  KV_SERIALIZE(block_header)
873  KV_SERIALIZE(tx_hashes)
874  KV_SERIALIZE(status)
875  KV_SERIALIZE(blob)
876  KV_SERIALIZE(json)
877  END_KV_SERIALIZE_MAP()
878  };
879 
880  };
881 
882  struct peer {
883  uint64_t id;
884  std::string host;
885  uint32_t ip;
886  uint16_t port;
887  uint64_t last_seen;
888 
889  peer() = default;
890 
891  peer(uint64_t id, const std::string &host, uint64_t last_seen)
892  : id(id), host(host), ip(0), port(0), last_seen(last_seen)
893  {}
894  peer(uint64_t id, uint32_t ip, uint16_t port, uint64_t last_seen)
895  : id(id), host(std::to_string(ip)), ip(ip), port(port), last_seen(last_seen)
896  {}
897 
898  BEGIN_KV_SERIALIZE_MAP()
899  KV_SERIALIZE(id)
900  KV_SERIALIZE(host)
901  KV_SERIALIZE(ip)
902  KV_SERIALIZE(port)
903  KV_SERIALIZE(last_seen)
904  END_KV_SERIALIZE_MAP()
905  };
906 
908  {
909  struct request
910  {
911  BEGIN_KV_SERIALIZE_MAP()
912  END_KV_SERIALIZE_MAP()
913  };
914 
915  struct response
916  {
917  std::string status;
918  std::vector<peer> white_list;
919  std::vector<peer> gray_list;
920 
921  BEGIN_KV_SERIALIZE_MAP()
922  KV_SERIALIZE(status)
923  KV_SERIALIZE(white_list)
924  KV_SERIALIZE(gray_list)
925  END_KV_SERIALIZE_MAP()
926  };
927  };
928 
930  {
931  struct request
932  {
933  bool visible;
934 
935  BEGIN_KV_SERIALIZE_MAP()
936  KV_SERIALIZE(visible)
937  END_KV_SERIALIZE_MAP()
938  };
939 
940  struct response
941  {
942  std::string status;
943  BEGIN_KV_SERIALIZE_MAP()
944  KV_SERIALIZE(status)
945  END_KV_SERIALIZE_MAP()
946  };
947  };
948 
950  {
951  struct request
952  {
953  int8_t level;
954 
955  BEGIN_KV_SERIALIZE_MAP()
956  KV_SERIALIZE(level)
957  END_KV_SERIALIZE_MAP()
958  };
959 
960  struct response
961  {
962  std::string status;
963  BEGIN_KV_SERIALIZE_MAP()
964  KV_SERIALIZE(status)
965  END_KV_SERIALIZE_MAP()
966  };
967  };
968 
970  {
971  struct request
972  {
973  std::string categories;
974 
975  BEGIN_KV_SERIALIZE_MAP()
976  KV_SERIALIZE(categories)
977  END_KV_SERIALIZE_MAP()
978  };
979 
980  struct response
981  {
982  std::string status;
983  BEGIN_KV_SERIALIZE_MAP()
984  KV_SERIALIZE(status)
985  END_KV_SERIALIZE_MAP()
986  };
987  };
988 
989  struct tx_info
990  {
991  std::string id_hash;
992  std::string tx_json; // TODO - expose this data directly
993  uint64_t blob_size;
994  uint64_t fee;
999  std::string last_failed_id_hash;
1000  uint64_t receive_time;
1001  bool relayed;
1004 
1005  BEGIN_KV_SERIALIZE_MAP()
1006  KV_SERIALIZE(id_hash)
1007  KV_SERIALIZE(tx_json)
1008  KV_SERIALIZE(blob_size)
1009  KV_SERIALIZE(fee)
1010  KV_SERIALIZE(max_used_block_id_hash)
1011  KV_SERIALIZE(max_used_block_height)
1012  KV_SERIALIZE(kept_by_block)
1013  KV_SERIALIZE(last_failed_height)
1014  KV_SERIALIZE(last_failed_id_hash)
1015  KV_SERIALIZE(receive_time)
1016  KV_SERIALIZE(relayed)
1017  KV_SERIALIZE(last_relayed_time)
1018  KV_SERIALIZE(do_not_relay)
1019  END_KV_SERIALIZE_MAP()
1020  };
1021 
1023  {
1024  std::string id_hash;
1025  std::vector<std::string> txs_hashes;
1026 
1027  BEGIN_KV_SERIALIZE_MAP()
1028  KV_SERIALIZE(id_hash)
1029  KV_SERIALIZE(txs_hashes)
1030  END_KV_SERIALIZE_MAP()
1031  };
1032 
1034  {
1035  struct request
1036  {
1037  BEGIN_KV_SERIALIZE_MAP()
1038  END_KV_SERIALIZE_MAP()
1039  };
1040 
1041  struct response
1042  {
1043  std::string status;
1044  std::vector<tx_info> transactions;
1045  std::vector<spent_key_image_info> spent_key_images;
1046 
1047  BEGIN_KV_SERIALIZE_MAP()
1048  KV_SERIALIZE(status)
1049  KV_SERIALIZE(transactions)
1050  KV_SERIALIZE(spent_key_images)
1051  END_KV_SERIALIZE_MAP()
1052  };
1053  };
1054 
1056  {
1057  struct request
1058  {
1059  BEGIN_KV_SERIALIZE_MAP()
1060  END_KV_SERIALIZE_MAP()
1061  };
1062 
1063  struct response
1064  {
1065  std::string status;
1066  std::vector<crypto::hash> tx_hashes;
1067 
1068  BEGIN_KV_SERIALIZE_MAP()
1069  KV_SERIALIZE(status)
1070  KV_SERIALIZE_CONTAINER_POD_AS_BLOB(tx_hashes)
1071  END_KV_SERIALIZE_MAP()
1072  };
1073  };
1074 
1076  {
1077  uint64_t blob_size;
1078  uint64_t fee;
1079  uint64_t time_in_pool;
1080  };
1081 
1083  {
1084  struct request
1085  {
1086  BEGIN_KV_SERIALIZE_MAP()
1087  END_KV_SERIALIZE_MAP()
1088  };
1089 
1090  struct response
1091  {
1092  std::string status;
1093  std::vector<tx_backlog_entry> backlog;
1094 
1095  BEGIN_KV_SERIALIZE_MAP()
1096  KV_SERIALIZE(status)
1097  KV_SERIALIZE_CONTAINER_POD_AS_BLOB(backlog)
1098  END_KV_SERIALIZE_MAP()
1099  };
1100  };
1101 
1103  {
1104  uint32_t txs;
1105  uint64_t bytes;
1106 
1107  BEGIN_KV_SERIALIZE_MAP()
1108  KV_SERIALIZE(txs)
1109  KV_SERIALIZE(bytes)
1110  END_KV_SERIALIZE_MAP()
1111  };
1112 
1114  {
1115  uint64_t bytes_total;
1116  uint32_t bytes_min;
1117  uint32_t bytes_max;
1118  uint64_t fee_total;
1119  uint64_t oldest;
1120  uint32_t txs_total;
1121  uint32_t num_failing;
1122  uint32_t num_10m;
1124  uint64_t histo_98pc;
1125  std::vector<txpool_histo> histo;
1126 
1127  BEGIN_KV_SERIALIZE_MAP()
1128  KV_SERIALIZE(bytes_total)
1129  KV_SERIALIZE(bytes_min)
1130  KV_SERIALIZE(bytes_max)
1131  KV_SERIALIZE(fee_total)
1132  KV_SERIALIZE(oldest)
1133  KV_SERIALIZE(txs_total)
1134  KV_SERIALIZE(num_failing)
1135  KV_SERIALIZE(num_10m)
1136  KV_SERIALIZE(num_not_relayed)
1137  KV_SERIALIZE(histo_98pc)
1138  KV_SERIALIZE_CONTAINER_POD_AS_BLOB(histo)
1139  END_KV_SERIALIZE_MAP()
1140  };
1141 
1143  {
1144  struct request
1145  {
1146  BEGIN_KV_SERIALIZE_MAP()
1147  END_KV_SERIALIZE_MAP()
1148  };
1149 
1150  struct response
1151  {
1152  std::string status;
1154 
1155  BEGIN_KV_SERIALIZE_MAP()
1156  KV_SERIALIZE(status)
1157  KV_SERIALIZE(pool_stats)
1158  END_KV_SERIALIZE_MAP()
1159  };
1160  };
1161 
1163  {
1164  struct request
1165  {
1166  BEGIN_KV_SERIALIZE_MAP()
1167  END_KV_SERIALIZE_MAP()
1168  };
1169 
1170  struct response
1171  {
1172  std::string status;
1173  std::list<connection_info> connections;
1174 
1175  BEGIN_KV_SERIALIZE_MAP()
1176  KV_SERIALIZE(status)
1177  KV_SERIALIZE(connections)
1178  END_KV_SERIALIZE_MAP()
1179  };
1180 
1181  };
1182 
1184  {
1185  struct request
1186  {
1187  uint64_t start_height;
1188  uint64_t end_height;
1189 
1190  BEGIN_KV_SERIALIZE_MAP()
1191  KV_SERIALIZE(start_height)
1192  KV_SERIALIZE(end_height)
1193  END_KV_SERIALIZE_MAP()
1194  };
1195 
1196  struct response
1197  {
1198  std::string status;
1199  std::vector<block_header_response> headers;
1200 
1201  BEGIN_KV_SERIALIZE_MAP()
1202  KV_SERIALIZE(status)
1203  KV_SERIALIZE(headers)
1204  END_KV_SERIALIZE_MAP()
1205  };
1206  };
1207 
1209  {
1210  struct request
1211  {
1212  BEGIN_KV_SERIALIZE_MAP()
1213  END_KV_SERIALIZE_MAP()
1214  };
1215 
1216  struct response
1217  {
1218  std::string status;
1219 
1220  BEGIN_KV_SERIALIZE_MAP()
1221  KV_SERIALIZE(status)
1222  END_KV_SERIALIZE_MAP()
1223  };
1224  };
1225 
1227  {
1228  struct request
1229  {
1230  BEGIN_KV_SERIALIZE_MAP()
1231  END_KV_SERIALIZE_MAP()
1232  };
1233 
1234  struct response
1235  {
1236  std::string status;
1237 
1238  BEGIN_KV_SERIALIZE_MAP()
1239  KV_SERIALIZE(status)
1240  END_KV_SERIALIZE_MAP()
1241  };
1242  };
1243 
1245  {
1246  struct request
1247  {
1248  uint64_t out_peers;
1249  BEGIN_KV_SERIALIZE_MAP()
1250  KV_SERIALIZE(out_peers)
1251  END_KV_SERIALIZE_MAP()
1252  };
1253 
1254  struct response
1255  {
1256  std::string status;
1257 
1258  BEGIN_KV_SERIALIZE_MAP()
1259  KV_SERIALIZE(status)
1260  END_KV_SERIALIZE_MAP()
1261  };
1262  };
1263 
1265  {
1266  struct request
1267  {
1268  BEGIN_KV_SERIALIZE_MAP()
1269  END_KV_SERIALIZE_MAP()
1270  };
1271 
1272  struct response
1273  {
1274  std::string status;
1275 
1276  BEGIN_KV_SERIALIZE_MAP()
1277  KV_SERIALIZE(status)
1278  END_KV_SERIALIZE_MAP()
1279  };
1280  };
1281 
1283  {
1284  struct request
1285  {
1286  BEGIN_KV_SERIALIZE_MAP()
1287  END_KV_SERIALIZE_MAP()
1288  };
1289 
1290  struct response
1291  {
1292  std::string status;
1293 
1294  BEGIN_KV_SERIALIZE_MAP()
1295  KV_SERIALIZE(status)
1296  END_KV_SERIALIZE_MAP()
1297  };
1298  };
1299 
1301  {
1302  struct request
1303  {
1304  uint8_t version;
1305 
1306  BEGIN_KV_SERIALIZE_MAP()
1307  KV_SERIALIZE(version)
1308  END_KV_SERIALIZE_MAP()
1309  };
1310 
1311  struct response
1312  {
1313  uint8_t version;
1314  bool enabled;
1315  uint32_t window;
1316  uint32_t votes;
1317  uint32_t threshold;
1318  uint8_t voting;
1319  uint32_t state;
1321  std::string status;
1322 
1323  BEGIN_KV_SERIALIZE_MAP()
1324  KV_SERIALIZE(version)
1325  KV_SERIALIZE(enabled)
1326  KV_SERIALIZE(window)
1327  KV_SERIALIZE(votes)
1328  KV_SERIALIZE(threshold)
1329  KV_SERIALIZE(voting)
1330  KV_SERIALIZE(state)
1331  KV_SERIALIZE(earliest_height)
1332  KV_SERIALIZE(status)
1333  END_KV_SERIALIZE_MAP()
1334  };
1335  };
1336 
1338  {
1339  struct ban
1340  {
1341  std::string host;
1342  uint32_t ip;
1343  uint32_t seconds;
1344 
1345  BEGIN_KV_SERIALIZE_MAP()
1346  KV_SERIALIZE(host)
1347  KV_SERIALIZE(ip)
1348  KV_SERIALIZE(seconds)
1349  END_KV_SERIALIZE_MAP()
1350  };
1351 
1352  struct request
1353  {
1354  BEGIN_KV_SERIALIZE_MAP()
1355  END_KV_SERIALIZE_MAP()
1356  };
1357 
1358  struct response
1359  {
1360  std::string status;
1361  std::vector<ban> bans;
1362 
1363  BEGIN_KV_SERIALIZE_MAP()
1364  KV_SERIALIZE(status)
1365  KV_SERIALIZE(bans)
1366  END_KV_SERIALIZE_MAP()
1367  };
1368  };
1369 
1371  {
1372  struct ban
1373  {
1374  std::string host;
1375  uint32_t ip;
1376  bool ban;
1377  uint32_t seconds;
1378 
1379  BEGIN_KV_SERIALIZE_MAP()
1380  KV_SERIALIZE(host)
1381  KV_SERIALIZE(ip)
1382  KV_SERIALIZE(ban)
1383  KV_SERIALIZE(seconds)
1384  END_KV_SERIALIZE_MAP()
1385  };
1386 
1387  struct request
1388  {
1389  std::vector<ban> bans;
1390 
1391  BEGIN_KV_SERIALIZE_MAP()
1392  KV_SERIALIZE(bans)
1393  END_KV_SERIALIZE_MAP()
1394  };
1395 
1396  struct response
1397  {
1398  std::string status;
1399 
1400  BEGIN_KV_SERIALIZE_MAP()
1401  KV_SERIALIZE(status)
1402  END_KV_SERIALIZE_MAP()
1403  };
1404  };
1405 
1407  {
1408  struct request
1409  {
1410  std::list<std::string> txids;
1411 
1412  BEGIN_KV_SERIALIZE_MAP()
1413  KV_SERIALIZE(txids)
1414  END_KV_SERIALIZE_MAP()
1415  };
1416 
1417  struct response
1418  {
1419  std::string status;
1420 
1421  BEGIN_KV_SERIALIZE_MAP()
1422  KV_SERIALIZE(status)
1423  END_KV_SERIALIZE_MAP()
1424  };
1425  };
1426 
1428  {
1429  struct request
1430  {
1431  std::vector<uint64_t> amounts;
1432  uint64_t min_count;
1433  uint64_t max_count;
1434  bool unlocked;
1435  uint64_t recent_cutoff;
1436 
1437  BEGIN_KV_SERIALIZE_MAP()
1438  KV_SERIALIZE(amounts);
1439  KV_SERIALIZE(min_count);
1440  KV_SERIALIZE(max_count);
1441  KV_SERIALIZE(unlocked);
1442  KV_SERIALIZE(recent_cutoff);
1443  END_KV_SERIALIZE_MAP()
1444  };
1445 
1446  struct entry
1447  {
1448  uint64_t amount;
1452 
1453  BEGIN_KV_SERIALIZE_MAP()
1454  KV_SERIALIZE(amount);
1455  KV_SERIALIZE(total_instances);
1456  KV_SERIALIZE(unlocked_instances);
1457  KV_SERIALIZE(recent_instances);
1458  END_KV_SERIALIZE_MAP()
1459 
1460  entry(uint64_t amount, uint64_t total_instances, uint64_t unlocked_instances, uint64_t recent_instances):
1461  amount(amount), total_instances(total_instances), unlocked_instances(unlocked_instances), recent_instances(recent_instances) {}
1462  entry() {}
1463  };
1464 
1465  struct response
1466  {
1467  std::string status;
1468  std::vector<entry> histogram;
1469 
1470  BEGIN_KV_SERIALIZE_MAP()
1471  KV_SERIALIZE(status)
1472  KV_SERIALIZE(histogram)
1473  END_KV_SERIALIZE_MAP()
1474  };
1475  };
1476 
1478  {
1479  struct request
1480  {
1481  BEGIN_KV_SERIALIZE_MAP()
1482  END_KV_SERIALIZE_MAP()
1483  };
1484 
1485  struct response
1486  {
1487  std::string status;
1488  uint32_t version;
1489 
1490  BEGIN_KV_SERIALIZE_MAP()
1491  KV_SERIALIZE(status)
1492  KV_SERIALIZE(version)
1493  END_KV_SERIALIZE_MAP()
1494  };
1495  };
1496 
1498  {
1499  struct request
1500  {
1501  uint64_t height;
1502  uint64_t count;
1503 
1504  BEGIN_KV_SERIALIZE_MAP()
1505  KV_SERIALIZE(height);
1506  KV_SERIALIZE(count);
1507  END_KV_SERIALIZE_MAP()
1508  };
1509 
1510  struct response
1511  {
1512  std::string status;
1514  uint64_t fee_amount;
1515 
1516  BEGIN_KV_SERIALIZE_MAP()
1517  KV_SERIALIZE(status)
1518  KV_SERIALIZE(emission_amount)
1519  KV_SERIALIZE(fee_amount)
1520  END_KV_SERIALIZE_MAP()
1521  };
1522  };
1523 
1525  {
1526  struct request
1527  {
1528  uint64_t grace_blocks;
1529 
1530  BEGIN_KV_SERIALIZE_MAP()
1531  KV_SERIALIZE(grace_blocks)
1532  END_KV_SERIALIZE_MAP()
1533  };
1534 
1535  struct response
1536  {
1537  std::string status;
1538  uint64_t fee;
1539 
1540  BEGIN_KV_SERIALIZE_MAP()
1541  KV_SERIALIZE(status)
1542  KV_SERIALIZE(fee)
1543  END_KV_SERIALIZE_MAP()
1544  };
1545  };
1546 
1548  {
1549  struct request
1550  {
1551  BEGIN_KV_SERIALIZE_MAP()
1552  END_KV_SERIALIZE_MAP()
1553  };
1554 
1555  struct chain_info
1556  {
1557  std::string block_hash;
1558  uint64_t height;
1559  uint64_t length;
1560  uint64_t difficulty;
1561 
1562  BEGIN_KV_SERIALIZE_MAP()
1563  KV_SERIALIZE(block_hash)
1564  KV_SERIALIZE(height)
1565  KV_SERIALIZE(length)
1566  KV_SERIALIZE(difficulty)
1567  END_KV_SERIALIZE_MAP()
1568  };
1569 
1570  struct response
1571  {
1572  std::string status;
1573  std::list<chain_info> chains;
1574 
1575  BEGIN_KV_SERIALIZE_MAP()
1576  KV_SERIALIZE(status)
1577  KV_SERIALIZE(chains)
1578  END_KV_SERIALIZE_MAP()
1579  };
1580  };
1581 
1583  {
1584  struct request
1585  {
1586  std::string command;
1587  std::string path;
1588 
1589  BEGIN_KV_SERIALIZE_MAP()
1590  KV_SERIALIZE(command);
1591  KV_SERIALIZE(path);
1592  END_KV_SERIALIZE_MAP()
1593  };
1594 
1595  struct response
1596  {
1597  std::string status;
1598  bool update;
1599  std::string version;
1600  std::string user_uri;
1601  std::string auto_uri;
1602  std::string hash;
1603  std::string path;
1604 
1605  BEGIN_KV_SERIALIZE_MAP()
1606  KV_SERIALIZE(status)
1607  KV_SERIALIZE(update)
1608  KV_SERIALIZE(version)
1609  KV_SERIALIZE(user_uri)
1610  KV_SERIALIZE(auto_uri)
1611  KV_SERIALIZE(hash)
1612  KV_SERIALIZE(path)
1613  END_KV_SERIALIZE_MAP()
1614  };
1615  };
1616 
1618  {
1619  struct request
1620  {
1621  std::list<std::string> txids;
1622 
1623  BEGIN_KV_SERIALIZE_MAP()
1624  KV_SERIALIZE(txids)
1625  END_KV_SERIALIZE_MAP()
1626  };
1627 
1628  struct response
1629  {
1630  std::string status;
1631 
1632  BEGIN_KV_SERIALIZE_MAP()
1633  KV_SERIALIZE(status)
1634  END_KV_SERIALIZE_MAP()
1635  };
1636  };
1637 
1639  {
1640  struct request
1641  {
1642  BEGIN_KV_SERIALIZE_MAP()
1643  END_KV_SERIALIZE_MAP()
1644  };
1645 
1646  struct peer
1647  {
1649 
1650  BEGIN_KV_SERIALIZE_MAP()
1651  KV_SERIALIZE(info)
1652  END_KV_SERIALIZE_MAP()
1653  };
1654 
1655  struct span
1656  {
1658  uint64_t nblocks;
1660  uint32_t rate;
1661  uint32_t speed;
1662  uint64_t size;
1663  std::string remote_address;
1664 
1665  BEGIN_KV_SERIALIZE_MAP()
1666  KV_SERIALIZE(start_block_height)
1667  KV_SERIALIZE(nblocks)
1668  KV_SERIALIZE_VAL_POD_AS_BLOB(connection_id)
1669  KV_SERIALIZE(rate)
1670  KV_SERIALIZE(speed)
1671  KV_SERIALIZE(size)
1672  KV_SERIALIZE(remote_address)
1673  END_KV_SERIALIZE_MAP()
1674  };
1675 
1676  struct response
1677  {
1678  std::string status;
1679  uint64_t height;
1680  uint64_t target_height;
1681  std::list<peer> peers;
1682  std::list<span> spans;
1683 
1684  BEGIN_KV_SERIALIZE_MAP()
1685  KV_SERIALIZE(status)
1686  KV_SERIALIZE(height)
1687  KV_SERIALIZE(target_height)
1688  KV_SERIALIZE(peers)
1689  KV_SERIALIZE(spans)
1690  END_KV_SERIALIZE_MAP()
1691  };
1692  };
1693 }
Definition: core_rpc_server_commands_defs.h:1584
std::string remote_address
Definition: core_rpc_server_commands_defs.h:1663
Definition: core_rpc_server_commands_defs.h:882
bool fee_too_low
Definition: core_rpc_server_commands_defs.h:500
std::string hash
Definition: core_rpc_server_commands_defs.h:1602
STATUS
Definition: core_rpc_server_commands_defs.h:257
std::list< chain_info > chains
Definition: core_rpc_server_commands_defs.h:1573
std::vector< uint64_t > request
Definition: core_rpc_server_commands_defs.h:691
peer(uint64_t id, uint32_t ip, uint16_t port, uint64_t last_seen)
Definition: core_rpc_server_commands_defs.h:894
uint64_t height
Definition: core_rpc_server_commands_defs.h:67
bool not_relayed
Definition: core_rpc_server_commands_defs.h:493
uint16_t port
Definition: core_rpc_server_commands_defs.h:886
uint64_t start_height
Definition: core_rpc_server_commands_defs.h:1187
uint64_t cumulative_difficulty
Definition: core_rpc_server_commands_defs.h:571
uint64_t reward
Definition: core_rpc_server_commands_defs.h:760
Definition: core_rpc_server_commands_defs.h:915
Definition: core_rpc_server_commands_defs.h:297
Definition: core_rpc_server_commands_defs.h:452
std::string status
Definition: core_rpc_server_commands_defs.h:1172
uint64_t outs_count
Definition: core_rpc_server_commands_defs.h:445
std::string status
Definition: core_rpc_server_commands_defs.h:1065
bool decode_as_json
Definition: core_rpc_server_commands_defs.h:204
uint32_t ip
Definition: core_rpc_server_commands_defs.h:1375
bool active
Definition: core_rpc_server_commands_defs.h:633
std::string address
Definition: core_rpc_server_commands_defs.h:636
uint64_t alt_blocks_count
Definition: core_rpc_server_commands_defs.h:564
Definition: core_rpc_server_commands_defs.h:77
std::string status
Definition: core_rpc_server_commands_defs.h:1360
std::string status
Definition: core_rpc_server_commands_defs.h:300
Definition: core_rpc_server_commands_defs.h:548
uint64_t current_height
Definition: core_rpc_server_commands_defs.h:186
Definition: core_rpc_server_commands_defs.h:339
uint64_t target
Definition: core_rpc_server_commands_defs.h:561
uint64_t start_time
Definition: core_rpc_server_commands_defs.h:573
uint64_t nblocks
Definition: core_rpc_server_commands_defs.h:1658
std::string prev_hash
Definition: core_rpc_server_commands_defs.h:716
bool ignore_battery
Definition: core_rpc_server_commands_defs.h:526
uint64_t start_height
Definition: core_rpc_server_commands_defs.h:175
Definition: core_rpc_server_commands_defs.h:1041
Definition: core_rpc_server_commands_defs.h:1164
Definition: core_rpc_server_commands_defs.h:1311
std::list< crypto::hash > m_block_ids
Definition: core_rpc_server_commands_defs.h:184
std::string as_json
Definition: core_rpc_server_commands_defs.h:216
std::string status
Definition: core_rpc_server_commands_defs.h:1419
std::string status
Definition: core_rpc_server_commands_defs.h:740
bool invalid_output
Definition: core_rpc_server_commands_defs.h:497
uint64_t reserve_size
Definition: core_rpc_server_commands_defs.h:701
std::string block_hash
Definition: core_rpc_server_commands_defs.h:1557
Definition: core_rpc_server_commands_defs.h:1339
uint8_t version
Definition: core_rpc_server_commands_defs.h:1304
uint64_t receive_time
Definition: core_rpc_server_commands_defs.h:1000
std::vector< spent_key_image_info > spent_key_images
Definition: core_rpc_server_commands_defs.h:1045
uint64_t height
Definition: core_rpc_server_commands_defs.h:417
Definition: core_rpc_server_commands_defs.h:1547
Definition: core_rpc_server_commands_defs.h:852
std::string id_hash
Definition: core_rpc_server_commands_defs.h:991
boost::uuids::uuid uuid
Definition: net_node_common.h:41
Definition: core_rpc_server_commands_defs.h:783
Definition: core_rpc_server_commands_defs.h:1465
Definition: core_rpc_server_commands_defs.h:403
std::list< std::string > txids
Definition: core_rpc_server_commands_defs.h:1410
std::string status
Definition: core_rpc_server_commands_defs.h:632
bool orphan_status
Definition: core_rpc_server_commands_defs.h:755
uint32_t num_10m
Definition: core_rpc_server_commands_defs.h:1122
std::list< peer > peers
Definition: core_rpc_server_commands_defs.h:1681
std::string auto_uri
Definition: core_rpc_server_commands_defs.h:1601
std::list< std::string > missed_tx
Definition: core_rpc_server_commands_defs.h:238
std::string status
Definition: core_rpc_server_commands_defs.h:791
Definition: core_rpc_server_commands_defs.h:1084
std::vector< std::string > request
Definition: core_rpc_server_commands_defs.h:736
uint64_t start_height
Definition: core_rpc_server_commands_defs.h:83
uint64_t start_height
Definition: core_rpc_server_commands_defs.h:185
Definition: core_rpc_server_commands_defs.h:1499
uint32_t ip
Definition: core_rpc_server_commands_defs.h:1342
uint64_t index
Definition: core_rpc_server_commands_defs.h:353
Definition: core_rpc_server_commands_defs.h:969
crypto::public_key key
Definition: core_rpc_server_commands_defs.h:374
connection_info info
Definition: core_rpc_server_commands_defs.h:1648
std::string status
Definition: core_rpc_server_commands_defs.h:115
uint64_t fee_total
Definition: core_rpc_server_commands_defs.h:1118
Definition: cryptonote_basic.h:355
Definition: core_rpc_server_commands_defs.h:1063
Definition: core_rpc_server_commands_defs.h:781
Definition: core_rpc_server_commands_defs.h:128
uint64_t count
Definition: core_rpc_server_commands_defs.h:678
Definition: core_rpc_server_commands_defs.h:321
uint64_t difficulty
Definition: core_rpc_server_commands_defs.h:712
bool not_rct
Definition: core_rpc_server_commands_defs.h:501
Definition: core_rpc_server_commands_defs.h:1406
std::string response
Definition: core_rpc_server_commands_defs.h:693
uint64_t depth
Definition: core_rpc_server_commands_defs.h:757
Definition: core_rpc_server_commands_defs.h:1284
std::string status
Definition: core_rpc_server_commands_defs.h:1572
Definition: core_rpc_server_commands_defs.h:1408
bool low_mixin
Definition: core_rpc_server_commands_defs.h:494
peer(uint64_t id, const std::string &host, uint64_t last_seen)
Definition: core_rpc_server_commands_defs.h:891
Definition: core_rpc_server_commands_defs.h:1300
bool too_big
Definition: core_rpc_server_commands_defs.h:498
Definition: core_rpc_server_commands_defs.h:1210
std::vector< int > spent_status
Definition: core_rpc_server_commands_defs.h:275
Definition: core_rpc_server_commands_defs.h:389
std::string reason
Definition: core_rpc_server_commands_defs.h:492
Definition: core_rpc_server_commands_defs.h:1485
std::string status
Definition: core_rpc_server_commands_defs.h:942
Definition: core_rpc_server_commands_defs.h:110
std::string status
Definition: core_rpc_server_commands_defs.h:1236
Definition: core_rpc_server_commands_defs.h:931
crypto::public_key out_key
Definition: core_rpc_server_commands_defs.h:456
Definition: core_rpc_server_commands_defs.h:1226
bool update
Definition: core_rpc_server_commands_defs.h:1598
Definition: block_queue.cpp:41
std::list< block_complete_entry > blocks
Definition: core_rpc_server_commands_defs.h:112
Definition: core_rpc_server_commands_defs.h:152
std::string status
Definition: core_rpc_server_commands_defs.h:68
Definition: core_rpc_server_commands_defs.h:1619
Definition: cryptonote_protocol_defs.h:47
uint64_t min_count
Definition: core_rpc_server_commands_defs.h:1432
Definition: core_rpc_server_commands_defs.h:65
uint64_t timestamp
Definition: core_rpc_server_commands_defs.h:752
Definition: core_rpc_server_commands_defs.h:1290
Definition: core_rpc_server_commands_defs.h:1055
std::string status
Definition: core_rpc_server_commands_defs.h:865
Definition: core_rpc_server_commands_defs.h:1429
std::string status
Definition: core_rpc_server_commands_defs.h:242
Definition: core_rpc_server_commands_defs.h:169
Definition: core_rpc_server_commands_defs.h:661
Definition: core_rpc_server_commands_defs.h:1352
bool invalid_input
Definition: core_rpc_server_commands_defs.h:496
Definition: core_rpc_server_commands_defs.h:255
Definition: core_rpc_server_commands_defs.h:1570
std::string miner_address
Definition: core_rpc_server_commands_defs.h:523
bool in_pool
Definition: core_rpc_server_commands_defs.h:217
bool unlocked
Definition: core_rpc_server_commands_defs.h:416
bool visible
Definition: core_rpc_server_commands_defs.h:933
std::string status
Definition: core_rpc_server_commands_defs.h:1398
uint64_t oldest
Definition: core_rpc_server_commands_defs.h:1119
Definition: core_rpc_server_commands_defs.h:804
uint64_t height
Definition: core_rpc_server_commands_defs.h:558
std::string status
Definition: core_rpc_server_commands_defs.h:1152
uint64_t height
Definition: core_rpc_server_commands_defs.h:1501
uint64_t fee
Definition: core_rpc_server_commands_defs.h:1078
Definition: core_rpc_server_commands_defs.h:1617
Definition: core_rpc_server_commands_defs.h:1372
std::vector< uint64_t > amounts
Definition: core_rpc_server_commands_defs.h:1431
uint64_t height
Definition: core_rpc_server_commands_defs.h:713
Definition: core_rpc_server_commands_defs.h:622
std::string status
Definition: core_rpc_server_commands_defs.h:815
Definition: core_rpc_server_commands_defs.h:521
uint8_t minor_version
Definition: core_rpc_server_commands_defs.h:751
Definition: core_rpc_server_commands_defs.h:412
std::string status
Definition: core_rpc_server_commands_defs.h:1274
std::string status
Definition: core_rpc_server_commands_defs.h:538
std::string command
Definition: core_rpc_server_commands_defs.h:1586
Definition: core_rpc_server_commands_defs.h:949
std::vector< uint64_t > output_indices
Definition: core_rpc_server_commands_defs.h:219
std::string status
Definition: core_rpc_server_commands_defs.h:187
uint64_t speed
Definition: core_rpc_server_commands_defs.h:634
Definition: core_rpc_server_commands_defs.h:676
uint8_t major_version
Definition: core_rpc_server_commands_defs.h:750
Definition: core_rpc_server_commands_defs.h:1022
Definition: core_rpc_server_commands_defs.h:734
Definition: core_rpc_server_commands_defs.h:1427
Definition: core_rpc_server_commands_defs.h:350
std::vector< tx_output_indices > indices
Definition: core_rpc_server_commands_defs.h:103
std::list< std::string > request
Definition: core_rpc_server_commands_defs.h:674
uint32_t ip
Definition: core_rpc_server_commands_defs.h:885
Definition: core_rpc_server_commands_defs.h:536
uint64_t fee_amount
Definition: core_rpc_server_commands_defs.h:1514
uint64_t bytes
Definition: core_rpc_server_commands_defs.h:1105
Definition: core_rpc_server_commands_defs.h:1640
Definition: core_rpc_server_commands_defs.h:130
Definition: core_rpc_server_commands_defs.h:689
std::string json
Definition: core_rpc_server_commands_defs.h:869
crypto::hash txid
Definition: core_rpc_server_commands_defs.h:378
std::string status
Definition: core_rpc_server_commands_defs.h:962
uint64_t height
Definition: core_rpc_server_commands_defs.h:855
block_header_response block_header
Definition: core_rpc_server_commands_defs.h:866
Definition: core_rpc_server_commands_defs.h:789
uint64_t max_used_block_height
Definition: core_rpc_server_commands_defs.h:996
std::vector< entry > txs
Definition: core_rpc_server_commands_defs.h:241
std::string hash
Definition: core_rpc_server_commands_defs.h:806
rct::key mask
Definition: core_rpc_server_commands_defs.h:375
bool ban
Definition: core_rpc_server_commands_defs.h:1376
Definition: core_rpc_server_commands_defs.h:1102
std::vector< tx_backlog_entry > backlog
Definition: core_rpc_server_commands_defs.h:1093
std::string status
Definition: core_rpc_server_commands_defs.h:1537
std::vector< crypto::hash > tx_hashes
Definition: core_rpc_server_commands_defs.h:1066
uint64_t last_failed_height
Definition: core_rpc_server_commands_defs.h:998
std::string status
Definition: core_rpc_server_commands_defs.h:392
Definition: core_rpc_server_commands_defs.h:1082
Definition: core_rpc_server_commands_defs.h:1090
crypto::hash txid
Definition: core_rpc_server_commands_defs.h:290
uint64_t unlocked_instances
Definition: core_rpc_server_commands_defs.h:1450
uint32_t version
Definition: core_rpc_server_commands_defs.h:1488
std::string tx_hash
Definition: core_rpc_server_commands_defs.h:214
Holds cryptonote related classes and helpers.
Definition: db_bdb.cpp:225
std::string status
Definition: core_rpc_server_commands_defs.h:276
uint64_t block_size
Definition: core_rpc_server_commands_defs.h:761
uint64_t total_instances
Definition: core_rpc_server_commands_defs.h:1449
uint64_t incoming_connections_count
Definition: core_rpc_server_commands_defs.h:566
Definition: core_rpc_server_commands_defs.h:1266
Definition: core_rpc_server_commands_defs.h:620
Definition: core_rpc_server_commands_defs.h:1446
Definition: core_rpc_server_commands_defs.h:1595
Definition: core_rpc_server_commands_defs.h:310
uint64_t recent_cutoff
Definition: core_rpc_server_commands_defs.h:1435
bool prune
Definition: core_rpc_server_commands_defs.h:84
uint32_t seconds
Definition: core_rpc_server_commands_defs.h:1377
std::string status
Definition: core_rpc_server_commands_defs.h:1043
Definition: core_rpc_server_commands_defs.h:940
boost::uuids::uuid connection_id
Definition: core_rpc_server_commands_defs.h:1659
std::vector< txpool_histo > histo
Definition: core_rpc_server_commands_defs.h:1125
uint32_t num_failing
Definition: core_rpc_server_commands_defs.h:1121
Definition: core_rpc_server_commands_defs.h:361
Definition: core_rpc_server_commands_defs.h:212
std::string top_block_hash
Definition: core_rpc_server_commands_defs.h:570
std::string status
Definition: core_rpc_server_commands_defs.h:1321
uint64_t bytes_total
Definition: core_rpc_server_commands_defs.h:1115
std::string status
Definition: core_rpc_server_commands_defs.h:1092
std::vector< uint64_t > o_indexes
Definition: core_rpc_server_commands_defs.h:299
Definition: core_rpc_server_commands_defs.h:1477
uint64_t amount
Definition: core_rpc_server_commands_defs.h:330
uint64_t difficulty
Definition: core_rpc_server_commands_defs.h:1560
uint64_t block_height
Definition: core_rpc_server_commands_defs.h:218
uint64_t blob_size
Definition: core_rpc_server_commands_defs.h:1077
Definition: core_rpc_server_commands_defs.h:1510
std::vector< uint64_t > amounts
Definition: core_rpc_server_commands_defs.h:312
Definition: core_rpc_server_commands_defs.h:1638
uint32_t txs
Definition: core_rpc_server_commands_defs.h:1104
Definition: core_rpc_server_commands_defs.h:1254
uint64_t end_height
Definition: core_rpc_server_commands_defs.h:1188
Definition: core_rpc_server_commands_defs.h:441
uint32_t bytes_min
Definition: core_rpc_server_commands_defs.h:1116
uint64_t grace_blocks
Definition: core_rpc_server_commands_defs.h:1528
Definition: core_rpc_server_commands_defs.h:1526
uint64_t block_size_limit
Definition: core_rpc_server_commands_defs.h:572
uint64_t global_amount_index
Definition: core_rpc_server_commands_defs.h:455
uint64_t outs_count
Definition: core_rpc_server_commands_defs.h:313
Definition: core_rpc_server_commands_defs.h:960
std::vector< outkey > outs
Definition: core_rpc_server_commands_defs.h:431
uint64_t blob_size
Definition: core_rpc_server_commands_defs.h:993
Definition: core_rpc_server_commands_defs.h:519
Definition: core_rpc_server_commands_defs.h:158
Definition: core_rpc_server_commands_defs.h:980
block_header_response block_header
Definition: core_rpc_server_commands_defs.h:816
uint8_t version
Definition: core_rpc_server_commands_defs.h:1313
bool double_spend
Definition: core_rpc_server_commands_defs.h:495
std::vector< peer > white_list
Definition: core_rpc_server_commands_defs.h:918
bool unlocked
Definition: core_rpc_server_commands_defs.h:376
std::string status
Definition: core_rpc_server_commands_defs.h:917
std::string blob
Definition: core_rpc_server_commands_defs.h:868
bool do_background_mining
Definition: core_rpc_server_commands_defs.h:525
Definition: core_rpc_server_commands_defs.h:929
uint64_t threads_count
Definition: core_rpc_server_commands_defs.h:524
bool overspend
Definition: core_rpc_server_commands_defs.h:499
Definition: core_rpc_server_commands_defs.h:826
std::list< std::string > txs_as_json
Definition: core_rpc_server_commands_defs.h:235
uint64_t histo_98pc
Definition: core_rpc_server_commands_defs.h:1124
std::list< span > spans
Definition: core_rpc_server_commands_defs.h:1682
std::string status
Definition: core_rpc_server_commands_defs.h:161
std::vector< block_complete_entry > blocks
Definition: core_rpc_server_commands_defs.h:140
Definition: core_rpc_server_commands_defs.h:1264
std::vector< tx_info > transactions
Definition: core_rpc_server_commands_defs.h:1044
std::vector< std::string > txs_hashes
Definition: core_rpc_server_commands_defs.h:1025
Definition: rctTypes.h:82
uint64_t global_amount_index
Definition: core_rpc_server_commands_defs.h:323
Definition: core_rpc_server_commands_defs.h:1646
bool enabled
Definition: core_rpc_server_commands_defs.h:1314
Definition: core_rpc_server_commands_defs.h:828
std::string status
Definition: core_rpc_server_commands_defs.h:464
Definition: core_rpc_server_commands_defs.h:80
std::string status
Definition: core_rpc_server_commands_defs.h:1487
Definition: core_rpc_server_commands_defs.h:1162
Definition: core_rpc_server_commands_defs.h:1033
Definition: core_rpc_server_commands_defs.h:1272
uint32_t threads_count
Definition: core_rpc_server_commands_defs.h:635
blobdata blocktemplate_blob
Definition: core_rpc_server_commands_defs.h:717
Definition: core_rpc_server_commands_defs.h:1417
std::string status
Definition: core_rpc_server_commands_defs.h:342
std::vector< block_header_response > headers
Definition: core_rpc_server_commands_defs.h:1199
uint64_t difficulty
Definition: core_rpc_server_commands_defs.h:560
Definition: core_rpc_server_commands_defs.h:1208
Definition: core_rpc_server_commands_defs.h:863
Definition: core_rpc_server_commands_defs.h:651
Definition: core_rpc_server_commands_defs.h:372
std::vector< peer > gray_list
Definition: core_rpc_server_commands_defs.h:919
std::string status
Definition: core_rpc_server_commands_defs.h:1467
Definition: core_rpc_server_commands_defs.h:286
Definition: core_rpc_server_commands_defs.h:92
Definition: core_rpc_server_commands_defs.h:273
Definition: core_rpc_server_commands_defs.h:802
std::string status
Definition: core_rpc_server_commands_defs.h:491
std::string mask
Definition: core_rpc_server_commands_defs.h:415
Definition: core_rpc_server_commands_defs.h:653
Definition: core_rpc_server_commands_defs.h:672
uint64_t recent_instances
Definition: core_rpc_server_commands_defs.h:1451
uint64_t earliest_height
Definition: core_rpc_server_commands_defs.h:1320
Definition: core_rpc_server_commands_defs.h:231
Definition: core_rpc_server_commands_defs.h:697
Definition: core_rpc_server_commands_defs.h:182
uint32_t votes
Definition: core_rpc_server_commands_defs.h:1316
POD_CLASS public_key
Definition: crypto.h:58
std::string hash
Definition: core_rpc_server_commands_defs.h:758
Definition: core_rpc_server_commands_defs.h:909
uint64_t start_block_height
Definition: core_rpc_server_commands_defs.h:1657
Definition: core_rpc_server_commands_defs.h:150
std::string status
Definition: core_rpc_server_commands_defs.h:1512
std::string user_uri
Definition: core_rpc_server_commands_defs.h:1600
int8_t level
Definition: core_rpc_server_commands_defs.h:953
Definition: core_rpc_server_commands_defs.h:907
std::string max_used_block_id_hash
Definition: core_rpc_server_commands_defs.h:995
std::vector< get_outputs_out > outputs
Definition: core_rpc_server_commands_defs.h:405
std::string status
Definition: core_rpc_server_commands_defs.h:141
std::vector< std::string > blks_hashes
Definition: core_rpc_server_commands_defs.h:160
uint64_t height
Definition: core_rpc_server_commands_defs.h:1679
uint64_t outgoing_connections_count
Definition: core_rpc_server_commands_defs.h:565
uint64_t fee
Definition: core_rpc_server_commands_defs.h:1538
Definition: core_rpc_server_commands_defs.h:201
std::vector< ban > bans
Definition: core_rpc_server_commands_defs.h:1361
std::string status
Definition: core_rpc_server_commands_defs.h:679
std::vector< uint64_t > heights
Definition: core_rpc_server_commands_defs.h:132
std::vector< std::string > key_images
Definition: core_rpc_server_commands_defs.h:265
Definition: core_rpc_server_commands_defs.h:699
uint8_t version
Definition: blockchain.cpp:86
uint64_t amount
Definition: core_rpc_server_commands_defs.h:454
Definition: core_rpc_server_commands_defs.h:599
uint64_t out_peers
Definition: core_rpc_server_commands_defs.h:1248
std::list< connection_info > connections
Definition: core_rpc_server_commands_defs.h:1173
Definition: core_rpc_server_commands_defs.h:1142
std::string blobdata
Definition: blobdatatype.h:36
uint64_t count
Definition: core_rpc_server_commands_defs.h:1502
Definition: core_rpc_server_commands_defs.h:1396
std::vector< std::string > tx_hashes
Definition: core_rpc_server_commands_defs.h:867
Definition: core_rpc_server_commands_defs.h:850
CXA_THROW_INFO_T * info
Definition: stack_trace.cpp:78
uint32_t nonce
Definition: core_rpc_server_commands_defs.h:754
std::list< crypto::hash > block_ids
Definition: core_rpc_server_commands_defs.h:82
std::string id_hash
Definition: core_rpc_server_commands_defs.h:1024
#define blocks
Definition: sha512-hash.c:11
uint64_t start_height
Definition: core_rpc_server_commands_defs.h:113
Definition: core_rpc_server_commands_defs.h:1170
std::string status
Definition: core_rpc_server_commands_defs.h:432
std::string path
Definition: core_rpc_server_commands_defs.h:1587
Definition: core_rpc_server_commands_defs.h:1113
uint64_t emission_amount
Definition: core_rpc_server_commands_defs.h:1513
Definition: core_rpc_server_commands_defs.h:363
Definition: core_rpc_server_commands_defs.h:489
std::string status
Definition: core_rpc_server_commands_defs.h:557
uint32_t seconds
Definition: core_rpc_server_commands_defs.h:1343
std::vector< block_output_indices > output_indices
Definition: core_rpc_server_commands_defs.h:116
uint64_t size
Definition: core_rpc_server_commands_defs.h:1662
std::string path
Definition: core_rpc_server_commands_defs.h:1603
Definition: core_rpc_server_commands_defs.h:989
Definition: core_rpc_server_commands_defs.h:738
uint64_t white_peerlist_size
Definition: core_rpc_server_commands_defs.h:567
std::string status
Definition: core_rpc_server_commands_defs.h:611
Definition: core_rpc_server_commands_defs.h:1676
Definition: core_rpc_server_commands_defs.h:263
std::string host
Definition: core_rpc_server_commands_defs.h:1374
entry()
Definition: core_rpc_server_commands_defs.h:1462
Definition: core_rpc_server_commands_defs.h:172
Definition: core_rpc_server_commands_defs.h:1628
std::uint64_t difficulty_type
Definition: difficulty.h:41
std::list< std::string > txs_hashes
Definition: core_rpc_server_commands_defs.h:203
uint64_t id
Definition: core_rpc_server_commands_defs.h:883
Definition: core_rpc_server_commands_defs.h:971
std::vector< uint64_t > indices
Definition: core_rpc_server_commands_defs.h:94
Definition: blake256.h:37
Definition: core_rpc_server_commands_defs.h:546
Definition: core_rpc_server_commands_defs.h:1150
uint32_t speed
Definition: core_rpc_server_commands_defs.h:1661
uint64_t tx_count
Definition: core_rpc_server_commands_defs.h:562
rct::key commitment
Definition: core_rpc_server_commands_defs.h:457
Definition: core_rpc_server_commands_defs.h:57
std::string key
Definition: core_rpc_server_commands_defs.h:414
Definition: core_rpc_server_commands_defs.h:1337
Definition: core_rpc_server_commands_defs.h:461
Definition: core_rpc_server_commands_defs.h:1524
Definition: core_rpc_server_commands_defs.h:1549
std::vector< outs_for_amount > outs
Definition: core_rpc_server_commands_defs.h:341
Definition: core_rpc_server_commands_defs.h:1246
Definition: core_rpc_server_commands_defs.h:199
Definition: core_rpc_server_commands_defs.h:1282
std::string tx_as_hex
Definition: core_rpc_server_commands_defs.h:476
std::string status
Definition: core_rpc_server_commands_defs.h:1256
std::list< std::string > txids
Definition: core_rpc_server_commands_defs.h:1621
uint64_t last_seen
Definition: core_rpc_server_commands_defs.h:887
Definition: core_rpc_server_commands_defs.h:630
Definition: core_rpc_server_commands_defs.h:710
Definition: core_rpc_server_commands_defs.h:138
uint8_t voting
Definition: core_rpc_server_commands_defs.h:1318
Definition: core_rpc_server_commands_defs.h:1244
uint64_t num_txes
Definition: core_rpc_server_commands_defs.h:762
Definition: core_rpc_server_commands_defs.h:1035
std::string txid
Definition: core_rpc_server_commands_defs.h:418
uint64_t grey_peerlist_size
Definition: core_rpc_server_commands_defs.h:568
Definition: core_rpc_server_commands_defs.h:429
Definition: core_rpc_server_commands_defs.h:1555
std::string status
Definition: core_rpc_server_commands_defs.h:663
uint64_t current_height
Definition: core_rpc_server_commands_defs.h:114
Definition: core_rpc_server_commands_defs.h:472
std::string status
Definition: core_rpc_server_commands_defs.h:1218
Definition: core_rpc_server_commands_defs.h:1370
std::vector< outkey > outs
Definition: core_rpc_server_commands_defs.h:391
Definition: core_rpc_server_commands_defs.h:1144
Definition: core_rpc_server_commands_defs.h:1183
Definition: core_rpc_server_commands_defs.h:1497
Definition: core_rpc_server_commands_defs.h:601
std::string status
Definition: core_rpc_server_commands_defs.h:719
Definition: core_rpc_server_commands_defs.h:1228
std::string status
Definition: core_rpc_server_commands_defs.h:1630
bool do_not_relay
Definition: core_rpc_server_commands_defs.h:477
uint64_t time_in_pool
Definition: core_rpc_server_commands_defs.h:1079
std::vector< ban > bans
Definition: core_rpc_server_commands_defs.h:1389
Definition: core_rpc_server_commands_defs.h:1216
uint64_t target_height
Definition: core_rpc_server_commands_defs.h:559
Definition: core_rpc_server_commands_defs.h:1185
std::string host
Definition: core_rpc_server_commands_defs.h:884
uint64_t length
Definition: core_rpc_server_commands_defs.h:1559
std::string status
Definition: core_rpc_server_commands_defs.h:839
POD_CLASS hash
Definition: hash.h:46
uint32_t rate
Definition: core_rpc_server_commands_defs.h:1660
difficulty_type difficulty
Definition: core_rpc_server_commands_defs.h:759
std::string categories
Definition: core_rpc_server_commands_defs.h:973
block_header_response block_header
Definition: core_rpc_server_commands_defs.h:840
Definition: core_rpc_server_commands_defs.h:288
Definition: core_rpc_server_commands_defs.h:1075
uint64_t target_height
Definition: core_rpc_server_commands_defs.h:1680
bool unlocked
Definition: core_rpc_server_commands_defs.h:1434
Definition: core_rpc_server_commands_defs.h:401
Definition: core_rpc_server_commands_defs.h:1655
bool do_not_relay
Definition: core_rpc_server_commands_defs.h:1003
std::string to_string(t_connection_type type)
Definition: connection_basic.cpp:96
std::string prev_hash
Definition: core_rpc_server_commands_defs.h:753
Definition: core_rpc_server_commands_defs.h:1387
Definition: core_rpc_server_commands_defs.h:813
Definition: core_rpc_server_commands_defs.h:748
std::string status
Definition: core_rpc_server_commands_defs.h:1678
uint64_t height
Definition: core_rpc_server_commands_defs.h:1558
std::string wallet_address
Definition: core_rpc_server_commands_defs.h:702
std::list< crypto::hash > block_ids
Definition: core_rpc_server_commands_defs.h:174
std::string tx_json
Definition: core_rpc_server_commands_defs.h:992
block_header_response block_header
Definition: core_rpc_server_commands_defs.h:792
bool testnet
Definition: core_rpc_server_commands_defs.h:569
std::string hash
Definition: core_rpc_server_commands_defs.h:854
std::string host
Definition: core_rpc_server_commands_defs.h:1341
std::list< out_entry > outs
Definition: core_rpc_server_commands_defs.h:463
uint32_t txs_total
Definition: core_rpc_server_commands_defs.h:1120
txpool_stats pool_stats
Definition: core_rpc_server_commands_defs.h:1153
Definition: core_rpc_server_commands_defs.h:1302
std::string as_hex
Definition: core_rpc_server_commands_defs.h:215
std::list< std::string > txs_as_hex
Definition: core_rpc_server_commands_defs.h:234
std::list< out_entry > outs
Definition: core_rpc_server_commands_defs.h:331
Definition: core_rpc_server_commands_defs.h:308
uint64_t height
Definition: core_rpc_server_commands_defs.h:830
std::vector< entry > histogram
Definition: core_rpc_server_commands_defs.h:1468
uint64_t max_count
Definition: core_rpc_server_commands_defs.h:1433
bool kept_by_block
Definition: core_rpc_server_commands_defs.h:997
Definition: core_rpc_server_commands_defs.h:101
request()
Definition: core_rpc_server_commands_defs.h:479
uint64_t reserved_offset
Definition: core_rpc_server_commands_defs.h:714
uint64_t amount
Definition: core_rpc_server_commands_defs.h:352
Definition: core_rpc_server_commands_defs.h:1234
std::string status
Definition: core_rpc_server_commands_defs.h:1597
std::vector< get_outputs_out > outputs
Definition: core_rpc_server_commands_defs.h:365
uint64_t fee
Definition: core_rpc_server_commands_defs.h:994
std::string status
Definition: core_rpc_server_commands_defs.h:982
uint64_t tx_pool_size
Definition: core_rpc_server_commands_defs.h:563
Definition: core_rpc_server_commands_defs.h:1582
bool relayed
Definition: core_rpc_server_commands_defs.h:1001
Definition: core_rpc_server_commands_defs.h:1479
uint32_t num_not_relayed
Definition: core_rpc_server_commands_defs.h:1123
Definition: core_rpc_server_commands_defs.h:1196
blobdata blockhashing_blob
Definition: core_rpc_server_commands_defs.h:718
crypto::public_key out_key
Definition: core_rpc_server_commands_defs.h:324
bool is_background_mining_enabled
Definition: core_rpc_server_commands_defs.h:637
Definition: core_rpc_server_commands_defs.h:1057
Definition: cryptonote_basic.h:188
std::string version
Definition: core_rpc_server_commands_defs.h:1599
uint32_t state
Definition: core_rpc_server_commands_defs.h:1319
Definition: core_rpc_server_commands_defs.h:837
std::string last_failed_id_hash
Definition: core_rpc_server_commands_defs.h:999
Definition: core_rpc_server_commands_defs.h:609
uint64_t last_relayed_time
Definition: core_rpc_server_commands_defs.h:1002
Definition: core_rpc_server_commands_defs.h:443
uint64_t height
Definition: core_rpc_server_commands_defs.h:377
uint64_t height
Definition: core_rpc_server_commands_defs.h:756
uint32_t window
Definition: core_rpc_server_commands_defs.h:1315
Definition: core_rpc_server_commands_defs.h:474
uint64_t expected_reward
Definition: core_rpc_server_commands_defs.h:715
std::string status
Definition: core_rpc_server_commands_defs.h:1292
Definition: core_rpc_server_commands_defs.h:1358
Definition: core_rpc_server_commands_defs.h:951
Definition: core_rpc_server_commands_defs.h:1535
std::string status
Definition: core_rpc_server_commands_defs.h:1198
Definition: core_rpc_server_commands_defs.h:555
uint64_t amount
Definition: core_rpc_server_commands_defs.h:1448
Definition: core_rpc_server_commands_defs.h:59
uint32_t threshold
Definition: core_rpc_server_commands_defs.h:1317
uint8_t threshold
Definition: blockchain.cpp:88
uint32_t bytes_max
Definition: core_rpc_server_commands_defs.h:1117