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