Electroneum
daemon_messages.h
Go to the documentation of this file.
1 // Copyright (c) 2016-2019, 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 #pragma once
30 
31 #include <unordered_map>
32 #include <vector>
33 
34 #include "message.h"
35 #include "cryptonote_protocol/cryptonote_protocol_defs.h"
36 #include "rpc/message_data_structs.h"
37 #include "rpc/daemon_rpc_version.h"
38 #include "cryptonote_basic/cryptonote_basic.h"
39 
40 #define BEGIN_RPC_MESSAGE_CLASS(classname) \
41 class classname \
42 { \
43  public: \
44  static const char* const name;
45 
46 #define BEGIN_RPC_MESSAGE_REQUEST \
47  class Request : public Message \
48  { \
49  public: \
50  Request() { } \
51  ~Request() { } \
52  rapidjson::Value toJson(rapidjson::Document& doc) const; \
53  void fromJson(rapidjson::Value& val);
54 
55 #define BEGIN_RPC_MESSAGE_RESPONSE \
56  class Response : public Message \
57  { \
58  public: \
59  Response() { } \
60  ~Response() { } \
61  rapidjson::Value toJson(rapidjson::Document& doc) const; \
62  void fromJson(rapidjson::Value& val);
63 
64 #define END_RPC_MESSAGE_REQUEST };
65 #define END_RPC_MESSAGE_RESPONSE };
66 #define END_RPC_MESSAGE_CLASS };
67 
68 // NOTE: when using a type with multiple template parameters,
69 // replace any comma in the template specifier with the macro
70 // above, or the preprocessor will eat the comma in a bad way.
71 #define RPC_MESSAGE_MEMBER(type, name) type name = {}
72 
73 
74 namespace cryptonote
75 {
76 
77 namespace rpc
78 {
79 
80 BEGIN_RPC_MESSAGE_CLASS(GetHeight);
81  BEGIN_RPC_MESSAGE_REQUEST;
82  END_RPC_MESSAGE_REQUEST;
83  BEGIN_RPC_MESSAGE_RESPONSE;
84  RPC_MESSAGE_MEMBER(uint64_t, height);
85  END_RPC_MESSAGE_RESPONSE;
86 END_RPC_MESSAGE_CLASS;
87 
88 
89 BEGIN_RPC_MESSAGE_CLASS(GetBlocksFast);
90  BEGIN_RPC_MESSAGE_REQUEST;
91  RPC_MESSAGE_MEMBER(std::list<crypto::hash>, block_ids);
92  RPC_MESSAGE_MEMBER(uint64_t, start_height);
93  RPC_MESSAGE_MEMBER(bool, prune);
94  END_RPC_MESSAGE_REQUEST;
95  BEGIN_RPC_MESSAGE_RESPONSE;
96  RPC_MESSAGE_MEMBER(std::vector<cryptonote::rpc::block_with_transactions>, blocks);
97  RPC_MESSAGE_MEMBER(uint64_t, start_height);
98  RPC_MESSAGE_MEMBER(uint64_t, current_height);
99  RPC_MESSAGE_MEMBER(std::vector<cryptonote::rpc::block_output_indices>, output_indices);
100  END_RPC_MESSAGE_RESPONSE;
101 END_RPC_MESSAGE_CLASS;
102 
103 
104 BEGIN_RPC_MESSAGE_CLASS(GetHashesFast);
105  BEGIN_RPC_MESSAGE_REQUEST;
106  RPC_MESSAGE_MEMBER(std::list<crypto::hash>, known_hashes);
107  RPC_MESSAGE_MEMBER(uint64_t, start_height);
108  END_RPC_MESSAGE_REQUEST;
109  BEGIN_RPC_MESSAGE_RESPONSE;
110  RPC_MESSAGE_MEMBER(std::vector<crypto::hash>, hashes);
111  RPC_MESSAGE_MEMBER(uint64_t, start_height);
112  RPC_MESSAGE_MEMBER(uint64_t, current_height);
113  END_RPC_MESSAGE_RESPONSE;
114 END_RPC_MESSAGE_CLASS;
115 
116 
117 BEGIN_RPC_MESSAGE_CLASS(GetTransactions);
118  BEGIN_RPC_MESSAGE_REQUEST;
119  RPC_MESSAGE_MEMBER(std::vector<crypto::hash>, tx_hashes);
120  END_RPC_MESSAGE_REQUEST;
121  BEGIN_RPC_MESSAGE_RESPONSE;
122  using txes_map = std::unordered_map<crypto::hash, transaction_info>;
123  RPC_MESSAGE_MEMBER(txes_map, txs);
124  RPC_MESSAGE_MEMBER(std::vector<crypto::hash>, missed_hashes);
125  END_RPC_MESSAGE_RESPONSE;
126 END_RPC_MESSAGE_CLASS;
127 
128 
129 BEGIN_RPC_MESSAGE_CLASS(KeyImagesSpent);
130  enum STATUS {
131  UNSPENT = 0,
132  SPENT_IN_BLOCKCHAIN = 1,
133  SPENT_IN_POOL = 2,
134  };
135  BEGIN_RPC_MESSAGE_REQUEST;
136  RPC_MESSAGE_MEMBER(std::vector<crypto::key_image>, key_images);
137  END_RPC_MESSAGE_REQUEST;
138  BEGIN_RPC_MESSAGE_RESPONSE;
139  RPC_MESSAGE_MEMBER(std::vector<uint64_t>, spent_status);
140  END_RPC_MESSAGE_RESPONSE;
141 END_RPC_MESSAGE_CLASS;
142 
143 
144 BEGIN_RPC_MESSAGE_CLASS(GetTxGlobalOutputIndices);
145  BEGIN_RPC_MESSAGE_REQUEST;
146  RPC_MESSAGE_MEMBER(crypto::hash, tx_hash);
147  END_RPC_MESSAGE_REQUEST;
148  BEGIN_RPC_MESSAGE_RESPONSE;
149  RPC_MESSAGE_MEMBER(std::vector<uint64_t>, output_indices);
150  END_RPC_MESSAGE_RESPONSE;
151 END_RPC_MESSAGE_CLASS;
152 
153 
154 BEGIN_RPC_MESSAGE_CLASS(GetRandomOutputsForAmounts);
155  BEGIN_RPC_MESSAGE_REQUEST;
156  RPC_MESSAGE_MEMBER(std::vector<uint64_t>, amounts);
157  RPC_MESSAGE_MEMBER(uint64_t, count);
158  END_RPC_MESSAGE_REQUEST;
159  BEGIN_RPC_MESSAGE_RESPONSE;
160  RPC_MESSAGE_MEMBER(std::vector<amount_with_random_outputs>, amounts_with_outputs);
161  END_RPC_MESSAGE_RESPONSE;
162 END_RPC_MESSAGE_CLASS;
163 
164 BEGIN_RPC_MESSAGE_CLASS(SendRawTx);
165  BEGIN_RPC_MESSAGE_REQUEST;
166  RPC_MESSAGE_MEMBER(cryptonote::transaction, tx);
167  RPC_MESSAGE_MEMBER(bool, relay);
168  END_RPC_MESSAGE_REQUEST;
169  BEGIN_RPC_MESSAGE_RESPONSE;
170  RPC_MESSAGE_MEMBER(bool, relayed);
171  END_RPC_MESSAGE_RESPONSE;
172 END_RPC_MESSAGE_CLASS;
173 
174 BEGIN_RPC_MESSAGE_CLASS(SendRawTxHex);
175  BEGIN_RPC_MESSAGE_REQUEST;
176  RPC_MESSAGE_MEMBER(std::string, tx_as_hex);
177  RPC_MESSAGE_MEMBER(bool, relay);
178  END_RPC_MESSAGE_REQUEST;
179  using Response = SendRawTx::Response;
180 END_RPC_MESSAGE_CLASS;
181 
182 BEGIN_RPC_MESSAGE_CLASS(StartMining);
183  BEGIN_RPC_MESSAGE_REQUEST;
184  RPC_MESSAGE_MEMBER(std::string, miner_address);
185  RPC_MESSAGE_MEMBER(uint64_t, threads_count);
186  RPC_MESSAGE_MEMBER(bool, do_background_mining);
187  RPC_MESSAGE_MEMBER(bool, ignore_battery);
188  END_RPC_MESSAGE_REQUEST;
189  BEGIN_RPC_MESSAGE_RESPONSE;
190  END_RPC_MESSAGE_RESPONSE;
191 END_RPC_MESSAGE_CLASS;
192 
193 BEGIN_RPC_MESSAGE_CLASS(GetInfo);
194  BEGIN_RPC_MESSAGE_REQUEST;
195  END_RPC_MESSAGE_REQUEST;
196  BEGIN_RPC_MESSAGE_RESPONSE;
197  RPC_MESSAGE_MEMBER(DaemonInfo, info);
198  END_RPC_MESSAGE_RESPONSE;
199 END_RPC_MESSAGE_CLASS;
200 
201 BEGIN_RPC_MESSAGE_CLASS(StopMining);
202  BEGIN_RPC_MESSAGE_REQUEST;
203  END_RPC_MESSAGE_REQUEST;
204  BEGIN_RPC_MESSAGE_RESPONSE;
205  END_RPC_MESSAGE_RESPONSE;
206 END_RPC_MESSAGE_CLASS;
207 
208 BEGIN_RPC_MESSAGE_CLASS(MiningStatus);
209  BEGIN_RPC_MESSAGE_REQUEST;
210  END_RPC_MESSAGE_REQUEST;
211  BEGIN_RPC_MESSAGE_RESPONSE;
212  RPC_MESSAGE_MEMBER(bool, active);
213  RPC_MESSAGE_MEMBER(uint64_t, speed);
214  RPC_MESSAGE_MEMBER(uint64_t, threads_count);
215  RPC_MESSAGE_MEMBER(std::string, address);
216  RPC_MESSAGE_MEMBER(bool, is_background_mining_enabled);
217  END_RPC_MESSAGE_RESPONSE;
218 END_RPC_MESSAGE_CLASS;
219 
220 BEGIN_RPC_MESSAGE_CLASS(SaveBC);
221  BEGIN_RPC_MESSAGE_REQUEST;
222  END_RPC_MESSAGE_REQUEST;
223  BEGIN_RPC_MESSAGE_RESPONSE;
224  END_RPC_MESSAGE_RESPONSE;
225 END_RPC_MESSAGE_CLASS;
226 
227 BEGIN_RPC_MESSAGE_CLASS(GetBlockHash);
228  BEGIN_RPC_MESSAGE_REQUEST;
229  RPC_MESSAGE_MEMBER(uint64_t, height);
230  END_RPC_MESSAGE_REQUEST;
231  BEGIN_RPC_MESSAGE_RESPONSE;
232  RPC_MESSAGE_MEMBER(crypto::hash, hash);
233  END_RPC_MESSAGE_RESPONSE;
234 END_RPC_MESSAGE_CLASS;
235 
236 BEGIN_RPC_MESSAGE_CLASS(GetBlockTemplate);
237  BEGIN_RPC_MESSAGE_REQUEST;
238  END_RPC_MESSAGE_REQUEST;
239  BEGIN_RPC_MESSAGE_RESPONSE;
240  END_RPC_MESSAGE_RESPONSE;
241 END_RPC_MESSAGE_CLASS;
242 
243 BEGIN_RPC_MESSAGE_CLASS(SubmitBlock);
244  BEGIN_RPC_MESSAGE_REQUEST;
245  END_RPC_MESSAGE_REQUEST;
246  BEGIN_RPC_MESSAGE_RESPONSE;
247  END_RPC_MESSAGE_RESPONSE;
248 END_RPC_MESSAGE_CLASS;
249 
250 BEGIN_RPC_MESSAGE_CLASS(GetLastBlockHeader);
251  BEGIN_RPC_MESSAGE_REQUEST;
252  END_RPC_MESSAGE_REQUEST;
253  BEGIN_RPC_MESSAGE_RESPONSE;
254  RPC_MESSAGE_MEMBER(cryptonote::rpc::BlockHeaderResponse, header);
255  END_RPC_MESSAGE_RESPONSE;
256 END_RPC_MESSAGE_CLASS;
257 
258 BEGIN_RPC_MESSAGE_CLASS(GetBlockHeaderByHash);
259  BEGIN_RPC_MESSAGE_REQUEST;
260  RPC_MESSAGE_MEMBER(crypto::hash, hash);
261  END_RPC_MESSAGE_REQUEST;
262  BEGIN_RPC_MESSAGE_RESPONSE;
263  RPC_MESSAGE_MEMBER(cryptonote::rpc::BlockHeaderResponse, header);
264  END_RPC_MESSAGE_RESPONSE;
265 END_RPC_MESSAGE_CLASS;
266 
267 BEGIN_RPC_MESSAGE_CLASS(GetBlockHeaderByHeight);
268  BEGIN_RPC_MESSAGE_REQUEST;
269  RPC_MESSAGE_MEMBER(uint64_t, height);
270  END_RPC_MESSAGE_REQUEST;
271  BEGIN_RPC_MESSAGE_RESPONSE;
272  RPC_MESSAGE_MEMBER(cryptonote::rpc::BlockHeaderResponse, header);
273  END_RPC_MESSAGE_RESPONSE;
274 END_RPC_MESSAGE_CLASS;
275 
276 BEGIN_RPC_MESSAGE_CLASS(GetBlockHeadersByHeight);
277  BEGIN_RPC_MESSAGE_REQUEST;
278  RPC_MESSAGE_MEMBER(std::vector<uint64_t>, heights);
279  END_RPC_MESSAGE_REQUEST;
280  BEGIN_RPC_MESSAGE_RESPONSE;
281  RPC_MESSAGE_MEMBER(std::vector<cryptonote::rpc::BlockHeaderResponse>, headers);
282  END_RPC_MESSAGE_RESPONSE;
283 END_RPC_MESSAGE_CLASS;
284 
285 BEGIN_RPC_MESSAGE_CLASS(GetBlock);
286  BEGIN_RPC_MESSAGE_REQUEST;
287  END_RPC_MESSAGE_REQUEST;
288  BEGIN_RPC_MESSAGE_RESPONSE;
289  END_RPC_MESSAGE_RESPONSE;
290 END_RPC_MESSAGE_CLASS;
291 
292 BEGIN_RPC_MESSAGE_CLASS(GetPeerList);
293  BEGIN_RPC_MESSAGE_REQUEST;
294  END_RPC_MESSAGE_REQUEST;
295  BEGIN_RPC_MESSAGE_RESPONSE;
296  RPC_MESSAGE_MEMBER(std::vector<peer>, white_list);
297  RPC_MESSAGE_MEMBER(std::vector<peer>, gray_list);
298  END_RPC_MESSAGE_RESPONSE;
299 END_RPC_MESSAGE_CLASS;
300 
301 BEGIN_RPC_MESSAGE_CLASS(SetLogHashRate);
302  BEGIN_RPC_MESSAGE_REQUEST;
303  END_RPC_MESSAGE_REQUEST;
304  BEGIN_RPC_MESSAGE_RESPONSE;
305  END_RPC_MESSAGE_RESPONSE;
306 END_RPC_MESSAGE_CLASS;
307 
308 BEGIN_RPC_MESSAGE_CLASS(SetLogLevel);
309  BEGIN_RPC_MESSAGE_REQUEST;
310  RPC_MESSAGE_MEMBER(int8_t, level);
311  END_RPC_MESSAGE_REQUEST;
312  BEGIN_RPC_MESSAGE_RESPONSE;
313  END_RPC_MESSAGE_RESPONSE;
314 END_RPC_MESSAGE_CLASS;
315 
316 BEGIN_RPC_MESSAGE_CLASS(GetTransactionPool);
317  BEGIN_RPC_MESSAGE_REQUEST;
318  END_RPC_MESSAGE_REQUEST;
319  BEGIN_RPC_MESSAGE_RESPONSE;
320  RPC_MESSAGE_MEMBER(std::vector<cryptonote::rpc::tx_in_pool>, transactions);
321  RPC_MESSAGE_MEMBER(key_images_with_tx_hashes, key_images);
322  END_RPC_MESSAGE_RESPONSE;
323 END_RPC_MESSAGE_CLASS;
324 
325 BEGIN_RPC_MESSAGE_CLASS(GetConnections);
326  BEGIN_RPC_MESSAGE_REQUEST;
327  END_RPC_MESSAGE_REQUEST;
328  BEGIN_RPC_MESSAGE_RESPONSE;
329  END_RPC_MESSAGE_RESPONSE;
330 END_RPC_MESSAGE_CLASS;
331 
332 BEGIN_RPC_MESSAGE_CLASS(GetBlockHeadersRange);
333  BEGIN_RPC_MESSAGE_REQUEST;
334  END_RPC_MESSAGE_REQUEST;
335  BEGIN_RPC_MESSAGE_RESPONSE;
336  END_RPC_MESSAGE_RESPONSE;
337 END_RPC_MESSAGE_CLASS;
338 
339 BEGIN_RPC_MESSAGE_CLASS(StopDaemon);
340  BEGIN_RPC_MESSAGE_REQUEST;
341  END_RPC_MESSAGE_REQUEST;
342  BEGIN_RPC_MESSAGE_RESPONSE;
343  END_RPC_MESSAGE_RESPONSE;
344 END_RPC_MESSAGE_CLASS;
345 
346 BEGIN_RPC_MESSAGE_CLASS(StartSaveGraph);
347  BEGIN_RPC_MESSAGE_REQUEST;
348  END_RPC_MESSAGE_REQUEST;
349  BEGIN_RPC_MESSAGE_RESPONSE;
350  END_RPC_MESSAGE_RESPONSE;
351 END_RPC_MESSAGE_CLASS;
352 
353 BEGIN_RPC_MESSAGE_CLASS(StopSaveGraph);
354  BEGIN_RPC_MESSAGE_REQUEST;
355  END_RPC_MESSAGE_REQUEST;
356  BEGIN_RPC_MESSAGE_RESPONSE;
357  END_RPC_MESSAGE_RESPONSE;
358 END_RPC_MESSAGE_CLASS;
359 
360 BEGIN_RPC_MESSAGE_CLASS(HardForkInfo);
361  BEGIN_RPC_MESSAGE_REQUEST;
362  RPC_MESSAGE_MEMBER(uint8_t, version);
363  END_RPC_MESSAGE_REQUEST;
364  BEGIN_RPC_MESSAGE_RESPONSE;
365  RPC_MESSAGE_MEMBER(hard_fork_info, info);
366  END_RPC_MESSAGE_RESPONSE;
367 END_RPC_MESSAGE_CLASS;
368 
369 BEGIN_RPC_MESSAGE_CLASS(GetBans);
370  BEGIN_RPC_MESSAGE_REQUEST;
371  END_RPC_MESSAGE_REQUEST;
372  BEGIN_RPC_MESSAGE_RESPONSE;
373  END_RPC_MESSAGE_RESPONSE;
374 END_RPC_MESSAGE_CLASS;
375 
376 BEGIN_RPC_MESSAGE_CLASS(SetBans);
377  BEGIN_RPC_MESSAGE_REQUEST;
378  END_RPC_MESSAGE_REQUEST;
379  BEGIN_RPC_MESSAGE_RESPONSE;
380  END_RPC_MESSAGE_RESPONSE;
381 END_RPC_MESSAGE_CLASS;
382 
383 BEGIN_RPC_MESSAGE_CLASS(FlushTransactionPool);
384  BEGIN_RPC_MESSAGE_REQUEST;
385  END_RPC_MESSAGE_REQUEST;
386  BEGIN_RPC_MESSAGE_RESPONSE;
387  END_RPC_MESSAGE_RESPONSE;
388 END_RPC_MESSAGE_CLASS;
389 
390 BEGIN_RPC_MESSAGE_CLASS(GetOutputHistogram);
391  BEGIN_RPC_MESSAGE_REQUEST;
392  RPC_MESSAGE_MEMBER(std::vector<uint64_t>, amounts);
393  RPC_MESSAGE_MEMBER(uint64_t, min_count);
394  RPC_MESSAGE_MEMBER(uint64_t, max_count);
395  RPC_MESSAGE_MEMBER(bool, unlocked);
396  RPC_MESSAGE_MEMBER(uint64_t, recent_cutoff);
397  END_RPC_MESSAGE_REQUEST;
398  BEGIN_RPC_MESSAGE_RESPONSE;
399  RPC_MESSAGE_MEMBER(std::vector<output_amount_count>, histogram);
400  END_RPC_MESSAGE_RESPONSE;
401 END_RPC_MESSAGE_CLASS;
402 
403 BEGIN_RPC_MESSAGE_CLASS(GetOutputKeys);
404  BEGIN_RPC_MESSAGE_REQUEST;
405  RPC_MESSAGE_MEMBER(std::vector<output_amount_and_index>, outputs);
406  END_RPC_MESSAGE_REQUEST;
407  BEGIN_RPC_MESSAGE_RESPONSE;
408  RPC_MESSAGE_MEMBER(std::vector<output_key_mask_unlocked>, keys);
409  END_RPC_MESSAGE_RESPONSE;
410 END_RPC_MESSAGE_CLASS;
411 
412 BEGIN_RPC_MESSAGE_CLASS(GetRPCVersion);
413  BEGIN_RPC_MESSAGE_REQUEST;
414  END_RPC_MESSAGE_REQUEST;
415  BEGIN_RPC_MESSAGE_RESPONSE;
416  RPC_MESSAGE_MEMBER(uint32_t, version);
417  END_RPC_MESSAGE_RESPONSE;
418 END_RPC_MESSAGE_CLASS;
419 
420 BEGIN_RPC_MESSAGE_CLASS(GetFeeEstimate);
421  BEGIN_RPC_MESSAGE_REQUEST;
422  RPC_MESSAGE_MEMBER(uint64_t, num_grace_blocks);
423  END_RPC_MESSAGE_REQUEST;
424  BEGIN_RPC_MESSAGE_RESPONSE;
425  RPC_MESSAGE_MEMBER(uint64_t, estimated_base_fee);
426  RPC_MESSAGE_MEMBER(uint64_t, fee_mask);
427  RPC_MESSAGE_MEMBER(uint32_t, size_scale);
428  RPC_MESSAGE_MEMBER(uint8_t, hard_fork_version);
429  END_RPC_MESSAGE_RESPONSE;
430 END_RPC_MESSAGE_CLASS;
431 
432 BEGIN_RPC_MESSAGE_CLASS(GetOutputDistribution);
433  BEGIN_RPC_MESSAGE_REQUEST;
434  RPC_MESSAGE_MEMBER(std::vector<uint64_t>, amounts);
435  RPC_MESSAGE_MEMBER(uint64_t, from_height);
436  RPC_MESSAGE_MEMBER(uint64_t, to_height);
437  RPC_MESSAGE_MEMBER(bool, cumulative);
438  END_RPC_MESSAGE_REQUEST;
439  BEGIN_RPC_MESSAGE_RESPONSE;
440  RPC_MESSAGE_MEMBER(std::vector<output_distribution>, distributions);
441  END_RPC_MESSAGE_RESPONSE;
442 END_RPC_MESSAGE_CLASS;
443 
444 } // namespace rpc
445 
446 } // namespace cryptonote
height
uint64_t height
Definition: blockchain.cpp:91
version
uint8_t version
Definition: blockchain.cpp:90
prune
static void prune(MDB_env *env0, MDB_env *env1)
Definition: blockchain_prune.cpp:247
cryptonote::transaction
Definition: cryptonote_basic.h:205
cryptonote_basic.h
cryptonote_protocol_defs.h
daemon_rpc_version.h
message_data_structs.h
blocks
Definition: blocks.cpp:13
crypto::hash
POD_CLASS hash
Definition: hash.h:50
cryptonote::rpc::END_RPC_MESSAGE_CLASS
END_RPC_MESSAGE_CLASS
Definition: daemon_messages.h:86
cryptonote::rpc::END_RPC_MESSAGE_REQUEST
END_RPC_MESSAGE_REQUEST
Definition: daemon_messages.h:82
cryptonote::rpc::BEGIN_RPC_MESSAGE_RESPONSE
BEGIN_RPC_MESSAGE_RESPONSE
Definition: daemon_messages.h:83
cryptonote::rpc::Response
SendRawTx::Response Response
Definition: daemon_messages.h:179
cryptonote::rpc::RPC_MESSAGE_MEMBER
RPC_MESSAGE_MEMBER(uint64_t, height)
cryptonote::rpc::BEGIN_RPC_MESSAGE_REQUEST
BEGIN_RPC_MESSAGE_REQUEST
Definition: daemon_messages.h:81
cryptonote::rpc::END_RPC_MESSAGE_RESPONSE
END_RPC_MESSAGE_RESPONSE
Definition: daemon_messages.h:85
cryptonote::rpc::key_images_with_tx_hashes
std::unordered_map< crypto::key_image, std::vector< crypto::hash > > key_images_with_tx_hashes
Definition: message_data_structs.h:106
cryptonote::rpc::STATUS
STATUS
Definition: daemon_messages.h:130
cryptonote::rpc::SPENT_IN_POOL
@ SPENT_IN_POOL
Definition: daemon_messages.h:133
cryptonote::rpc::SPENT_IN_BLOCKCHAIN
@ SPENT_IN_BLOCKCHAIN
Definition: daemon_messages.h:132
cryptonote::rpc::UNSPENT
@ UNSPENT
Definition: daemon_messages.h:131
cryptonote::rpc::BEGIN_RPC_MESSAGE_CLASS
BEGIN_RPC_MESSAGE_CLASS(GetHeight)
cryptonote::rpc::txes_map
std::unordered_map< crypto::hash, transaction_info > txes_map
Definition: daemon_messages.h:122
cryptonote
Holds cryptonote related classes and helpers.
Definition: db_bdb.cpp:226
lmdb::stream::count
mdb_size_t count(MDB_cursor *cur)
Definition: value_stream.cpp:39
info
CXA_THROW_INFO_T * info
Definition: stack_trace.cpp:91
cryptonote::rpc::BlockHeaderResponse
Definition: message_data_structs.h:160
cryptonote::rpc::DaemonInfo
Definition: message_data_structs.h:175
cryptonote::rpc::hard_fork_info
Definition: message_data_structs.h:130
Generated on Sat Aug 29 2020 00:00:00 for Electroneum by doxygen 1.9.1