Electroneum
Loading...
Searching...
No Matches
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) \
41class 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
74namespace cryptonote
75{
76
77namespace rpc
78{
79
80BEGIN_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;
86END_RPC_MESSAGE_CLASS;
87
88
89BEGIN_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;
101END_RPC_MESSAGE_CLASS;
102
103
104BEGIN_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;
114END_RPC_MESSAGE_CLASS;
115
116
117BEGIN_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;
126END_RPC_MESSAGE_CLASS;
127
128
129BEGIN_RPC_MESSAGE_CLASS(KeyImagesSpent);
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;
141END_RPC_MESSAGE_CLASS;
142
143
144BEGIN_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;
151END_RPC_MESSAGE_CLASS;
152
153
154BEGIN_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;
162END_RPC_MESSAGE_CLASS;
163
164BEGIN_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;
172END_RPC_MESSAGE_CLASS;
173
174BEGIN_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;
180END_RPC_MESSAGE_CLASS;
181
182BEGIN_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;
191END_RPC_MESSAGE_CLASS;
192
193BEGIN_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;
199END_RPC_MESSAGE_CLASS;
200
201BEGIN_RPC_MESSAGE_CLASS(StopMining);
202 BEGIN_RPC_MESSAGE_REQUEST;
203 END_RPC_MESSAGE_REQUEST;
204 BEGIN_RPC_MESSAGE_RESPONSE;
205 END_RPC_MESSAGE_RESPONSE;
206END_RPC_MESSAGE_CLASS;
207
208BEGIN_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;
218END_RPC_MESSAGE_CLASS;
219
220BEGIN_RPC_MESSAGE_CLASS(SaveBC);
221 BEGIN_RPC_MESSAGE_REQUEST;
222 END_RPC_MESSAGE_REQUEST;
223 BEGIN_RPC_MESSAGE_RESPONSE;
224 END_RPC_MESSAGE_RESPONSE;
225END_RPC_MESSAGE_CLASS;
226
227BEGIN_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;
234END_RPC_MESSAGE_CLASS;
235
236BEGIN_RPC_MESSAGE_CLASS(GetBlockTemplate);
237 BEGIN_RPC_MESSAGE_REQUEST;
238 END_RPC_MESSAGE_REQUEST;
239 BEGIN_RPC_MESSAGE_RESPONSE;
240 END_RPC_MESSAGE_RESPONSE;
241END_RPC_MESSAGE_CLASS;
242
243BEGIN_RPC_MESSAGE_CLASS(SubmitBlock);
244 BEGIN_RPC_MESSAGE_REQUEST;
245 END_RPC_MESSAGE_REQUEST;
246 BEGIN_RPC_MESSAGE_RESPONSE;
247 END_RPC_MESSAGE_RESPONSE;
248END_RPC_MESSAGE_CLASS;
249
250BEGIN_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;
256END_RPC_MESSAGE_CLASS;
257
258BEGIN_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;
265END_RPC_MESSAGE_CLASS;
266
267BEGIN_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;
274END_RPC_MESSAGE_CLASS;
275
276BEGIN_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;
283END_RPC_MESSAGE_CLASS;
284
285BEGIN_RPC_MESSAGE_CLASS(GetBlock);
286 BEGIN_RPC_MESSAGE_REQUEST;
287 END_RPC_MESSAGE_REQUEST;
288 BEGIN_RPC_MESSAGE_RESPONSE;
289 END_RPC_MESSAGE_RESPONSE;
290END_RPC_MESSAGE_CLASS;
291
292BEGIN_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;
299END_RPC_MESSAGE_CLASS;
300
301BEGIN_RPC_MESSAGE_CLASS(SetLogHashRate);
302 BEGIN_RPC_MESSAGE_REQUEST;
303 END_RPC_MESSAGE_REQUEST;
304 BEGIN_RPC_MESSAGE_RESPONSE;
305 END_RPC_MESSAGE_RESPONSE;
306END_RPC_MESSAGE_CLASS;
307
308BEGIN_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;
314END_RPC_MESSAGE_CLASS;
315
316BEGIN_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;
323END_RPC_MESSAGE_CLASS;
324
325BEGIN_RPC_MESSAGE_CLASS(GetConnections);
326 BEGIN_RPC_MESSAGE_REQUEST;
327 END_RPC_MESSAGE_REQUEST;
328 BEGIN_RPC_MESSAGE_RESPONSE;
329 END_RPC_MESSAGE_RESPONSE;
330END_RPC_MESSAGE_CLASS;
331
332BEGIN_RPC_MESSAGE_CLASS(GetBlockHeadersRange);
333 BEGIN_RPC_MESSAGE_REQUEST;
334 END_RPC_MESSAGE_REQUEST;
335 BEGIN_RPC_MESSAGE_RESPONSE;
336 END_RPC_MESSAGE_RESPONSE;
337END_RPC_MESSAGE_CLASS;
338
339BEGIN_RPC_MESSAGE_CLASS(StopDaemon);
340 BEGIN_RPC_MESSAGE_REQUEST;
341 END_RPC_MESSAGE_REQUEST;
342 BEGIN_RPC_MESSAGE_RESPONSE;
343 END_RPC_MESSAGE_RESPONSE;
344END_RPC_MESSAGE_CLASS;
345
346BEGIN_RPC_MESSAGE_CLASS(StartSaveGraph);
347 BEGIN_RPC_MESSAGE_REQUEST;
348 END_RPC_MESSAGE_REQUEST;
349 BEGIN_RPC_MESSAGE_RESPONSE;
350 END_RPC_MESSAGE_RESPONSE;
351END_RPC_MESSAGE_CLASS;
352
353BEGIN_RPC_MESSAGE_CLASS(StopSaveGraph);
354 BEGIN_RPC_MESSAGE_REQUEST;
355 END_RPC_MESSAGE_REQUEST;
356 BEGIN_RPC_MESSAGE_RESPONSE;
357 END_RPC_MESSAGE_RESPONSE;
358END_RPC_MESSAGE_CLASS;
359
360BEGIN_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;
367END_RPC_MESSAGE_CLASS;
368
369BEGIN_RPC_MESSAGE_CLASS(GetBans);
370 BEGIN_RPC_MESSAGE_REQUEST;
371 END_RPC_MESSAGE_REQUEST;
372 BEGIN_RPC_MESSAGE_RESPONSE;
373 END_RPC_MESSAGE_RESPONSE;
374END_RPC_MESSAGE_CLASS;
375
376BEGIN_RPC_MESSAGE_CLASS(SetBans);
377 BEGIN_RPC_MESSAGE_REQUEST;
378 END_RPC_MESSAGE_REQUEST;
379 BEGIN_RPC_MESSAGE_RESPONSE;
380 END_RPC_MESSAGE_RESPONSE;
381END_RPC_MESSAGE_CLASS;
382
383BEGIN_RPC_MESSAGE_CLASS(FlushTransactionPool);
384 BEGIN_RPC_MESSAGE_REQUEST;
385 END_RPC_MESSAGE_REQUEST;
386 BEGIN_RPC_MESSAGE_RESPONSE;
387 END_RPC_MESSAGE_RESPONSE;
388END_RPC_MESSAGE_CLASS;
389
390BEGIN_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;
401END_RPC_MESSAGE_CLASS;
402
403BEGIN_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;
410END_RPC_MESSAGE_CLASS;
411
412BEGIN_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;
418END_RPC_MESSAGE_CLASS;
419
420BEGIN_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;
430END_RPC_MESSAGE_CLASS;
431
432BEGIN_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;
442END_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
cryptonote_basic.h
cryptonote_protocol_defs.h
BEGIN_RPC_MESSAGE_CLASS
#define BEGIN_RPC_MESSAGE_CLASS(classname)
Definition daemon_messages.h:40
BEGIN_RPC_MESSAGE_REQUEST
#define BEGIN_RPC_MESSAGE_REQUEST
Definition daemon_messages.h:46
RPC_MESSAGE_MEMBER
#define RPC_MESSAGE_MEMBER(type, name)
Definition daemon_messages.h:71
daemon_rpc_version.h
message_data_structs.h
crypto::hash
POD_CLASS hash
Definition hash.h:50
cryptonote::rpc::Response
SendRawTx::Response Response
Definition daemon_messages.h:179
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
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 ban.cpp:40
info
CXA_THROW_INFO_T * info
Definition stack_trace.cpp:91
uint32_t
unsigned int uint32_t
Definition stdint.h:126
uint8_t
unsigned char uint8_t
Definition stdint.h:124
uint64_t
unsigned __int64 uint64_t
Definition stdint.h:136
int8_t
signed char int8_t
Definition stdint.h:121
cryptonote::rpc::hard_fork_info
Definition message_data_structs.h:131
hashes
struct hash_func hashes[]
address
const char * address
Definition multisig.cpp:37