Monero
Loading...
Searching...
No Matches
daemon_messages.h
Go to the documentation of this file.
1// Copyright (c) 2016-2022, The Monero Project
2//
3// All rights reserved.
4//
5// Redistribution and use in source and binary forms, with or without modification, are
6// permitted provided that the following conditions are met:
7//
8// 1. Redistributions of source code must retain the above copyright notice, this list of
9// conditions and the following disclaimer.
10//
11// 2. Redistributions in binary form must reproduce the above copyright notice, this list
12// of conditions and the following disclaimer in the documentation and/or other
13// materials provided with the distribution.
14//
15// 3. Neither the name of the copyright holder nor the names of its contributors may be
16// used to endorse or promote products derived from this software without specific
17// prior written permission.
18//
19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
20// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
22// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
26// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
27// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
29#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) \
43class 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
75namespace cryptonote
76{
77
78namespace rpc
79{
80
81BEGIN_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;
87END_RPC_MESSAGE_CLASS;
88
89
90BEGIN_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 RPC_MESSAGE_MEMBER(uint64_t, max_block_count);
102 END_RPC_MESSAGE_RESPONSE;
103END_RPC_MESSAGE_CLASS;
104
105
106BEGIN_RPC_MESSAGE_CLASS(GetHashesFast);
107 BEGIN_RPC_MESSAGE_REQUEST;
108 RPC_MESSAGE_MEMBER(std::list<crypto::hash>, known_hashes);
109 RPC_MESSAGE_MEMBER(uint64_t, start_height);
110 END_RPC_MESSAGE_REQUEST;
111 BEGIN_RPC_MESSAGE_RESPONSE;
112 RPC_MESSAGE_MEMBER(std::vector<crypto::hash>, hashes);
113 RPC_MESSAGE_MEMBER(uint64_t, start_height);
114 RPC_MESSAGE_MEMBER(uint64_t, current_height);
115 END_RPC_MESSAGE_RESPONSE;
116END_RPC_MESSAGE_CLASS;
117
118
119BEGIN_RPC_MESSAGE_CLASS(GetTransactions);
120 BEGIN_RPC_MESSAGE_REQUEST;
121 RPC_MESSAGE_MEMBER(std::vector<crypto::hash>, tx_hashes);
122 END_RPC_MESSAGE_REQUEST;
123 BEGIN_RPC_MESSAGE_RESPONSE;
124 using txes_map = std::unordered_map<crypto::hash, transaction_info>;
125 RPC_MESSAGE_MEMBER(txes_map, txs);
126 RPC_MESSAGE_MEMBER(std::vector<crypto::hash>, missed_hashes);
127 END_RPC_MESSAGE_RESPONSE;
128END_RPC_MESSAGE_CLASS;
129
130
131BEGIN_RPC_MESSAGE_CLASS(KeyImagesSpent);
137 BEGIN_RPC_MESSAGE_REQUEST;
138 RPC_MESSAGE_MEMBER(std::vector<crypto::key_image>, key_images);
139 END_RPC_MESSAGE_REQUEST;
140 BEGIN_RPC_MESSAGE_RESPONSE;
141 RPC_MESSAGE_MEMBER(std::vector<uint64_t>, spent_status);
142 END_RPC_MESSAGE_RESPONSE;
143END_RPC_MESSAGE_CLASS;
144
145
146BEGIN_RPC_MESSAGE_CLASS(GetTxGlobalOutputIndices);
147 BEGIN_RPC_MESSAGE_REQUEST;
148 RPC_MESSAGE_MEMBER(crypto::hash, tx_hash);
149 END_RPC_MESSAGE_REQUEST;
150 BEGIN_RPC_MESSAGE_RESPONSE;
151 RPC_MESSAGE_MEMBER(std::vector<uint64_t>, output_indices);
152 END_RPC_MESSAGE_RESPONSE;
153END_RPC_MESSAGE_CLASS;
154
155
156BEGIN_RPC_MESSAGE_CLASS(GetRandomOutputsForAmounts);
157 BEGIN_RPC_MESSAGE_REQUEST;
158 RPC_MESSAGE_MEMBER(std::vector<uint64_t>, amounts);
159 RPC_MESSAGE_MEMBER(uint64_t, count);
160 END_RPC_MESSAGE_REQUEST;
161 BEGIN_RPC_MESSAGE_RESPONSE;
162 RPC_MESSAGE_MEMBER(std::vector<amount_with_random_outputs>, amounts_with_outputs);
163 END_RPC_MESSAGE_RESPONSE;
164END_RPC_MESSAGE_CLASS;
165
166BEGIN_RPC_MESSAGE_CLASS(SendRawTx);
167 BEGIN_RPC_MESSAGE_REQUEST;
168 RPC_MESSAGE_MEMBER(cryptonote::transaction, tx);
169 RPC_MESSAGE_MEMBER(bool, relay);
170 END_RPC_MESSAGE_REQUEST;
171 BEGIN_RPC_MESSAGE_RESPONSE;
172 RPC_MESSAGE_MEMBER(bool, relayed);
173 END_RPC_MESSAGE_RESPONSE;
174END_RPC_MESSAGE_CLASS;
175
176BEGIN_RPC_MESSAGE_CLASS(SendRawTxHex);
177 BEGIN_RPC_MESSAGE_REQUEST;
178 RPC_MESSAGE_MEMBER(std::string, tx_as_hex);
179 RPC_MESSAGE_MEMBER(bool, relay);
180 END_RPC_MESSAGE_REQUEST;
181 using Response = SendRawTx::Response;
182END_RPC_MESSAGE_CLASS;
183
184BEGIN_RPC_MESSAGE_CLASS(StartMining);
185 BEGIN_RPC_MESSAGE_REQUEST;
186 RPC_MESSAGE_MEMBER(std::string, miner_address);
187 RPC_MESSAGE_MEMBER(uint64_t, threads_count);
188 RPC_MESSAGE_MEMBER(bool, do_background_mining);
189 RPC_MESSAGE_MEMBER(bool, ignore_battery);
190 END_RPC_MESSAGE_REQUEST;
191 BEGIN_RPC_MESSAGE_RESPONSE;
192 END_RPC_MESSAGE_RESPONSE;
193END_RPC_MESSAGE_CLASS;
194
195BEGIN_RPC_MESSAGE_CLASS(GetInfo);
196 BEGIN_RPC_MESSAGE_REQUEST;
197 END_RPC_MESSAGE_REQUEST;
198 BEGIN_RPC_MESSAGE_RESPONSE;
199 RPC_MESSAGE_MEMBER(DaemonInfo, info);
200 END_RPC_MESSAGE_RESPONSE;
201END_RPC_MESSAGE_CLASS;
202
203BEGIN_RPC_MESSAGE_CLASS(StopMining);
204 BEGIN_RPC_MESSAGE_REQUEST;
205 END_RPC_MESSAGE_REQUEST;
206 BEGIN_RPC_MESSAGE_RESPONSE;
207 END_RPC_MESSAGE_RESPONSE;
208END_RPC_MESSAGE_CLASS;
209
210BEGIN_RPC_MESSAGE_CLASS(MiningStatus);
211 BEGIN_RPC_MESSAGE_REQUEST;
212 END_RPC_MESSAGE_REQUEST;
213 BEGIN_RPC_MESSAGE_RESPONSE;
214 RPC_MESSAGE_MEMBER(bool, active);
215 RPC_MESSAGE_MEMBER(uint64_t, speed);
216 RPC_MESSAGE_MEMBER(uint64_t, threads_count);
217 RPC_MESSAGE_MEMBER(std::string, address);
218 RPC_MESSAGE_MEMBER(bool, is_background_mining_enabled);
219 END_RPC_MESSAGE_RESPONSE;
220END_RPC_MESSAGE_CLASS;
221
222BEGIN_RPC_MESSAGE_CLASS(SaveBC);
223 BEGIN_RPC_MESSAGE_REQUEST;
224 END_RPC_MESSAGE_REQUEST;
225 BEGIN_RPC_MESSAGE_RESPONSE;
226 END_RPC_MESSAGE_RESPONSE;
227END_RPC_MESSAGE_CLASS;
228
229BEGIN_RPC_MESSAGE_CLASS(GetBlockHash);
230 BEGIN_RPC_MESSAGE_REQUEST;
231 RPC_MESSAGE_MEMBER(uint64_t, height);
232 END_RPC_MESSAGE_REQUEST;
233 BEGIN_RPC_MESSAGE_RESPONSE;
234 RPC_MESSAGE_MEMBER(crypto::hash, hash);
235 END_RPC_MESSAGE_RESPONSE;
236END_RPC_MESSAGE_CLASS;
237
238BEGIN_RPC_MESSAGE_CLASS(GetBlockTemplate);
239 BEGIN_RPC_MESSAGE_REQUEST;
240 END_RPC_MESSAGE_REQUEST;
241 BEGIN_RPC_MESSAGE_RESPONSE;
242 END_RPC_MESSAGE_RESPONSE;
243END_RPC_MESSAGE_CLASS;
244
245BEGIN_RPC_MESSAGE_CLASS(SubmitBlock);
246 BEGIN_RPC_MESSAGE_REQUEST;
247 END_RPC_MESSAGE_REQUEST;
248 BEGIN_RPC_MESSAGE_RESPONSE;
249 END_RPC_MESSAGE_RESPONSE;
250END_RPC_MESSAGE_CLASS;
251
252BEGIN_RPC_MESSAGE_CLASS(GetLastBlockHeader);
253 BEGIN_RPC_MESSAGE_REQUEST;
254 END_RPC_MESSAGE_REQUEST;
255 BEGIN_RPC_MESSAGE_RESPONSE;
256 RPC_MESSAGE_MEMBER(cryptonote::rpc::BlockHeaderResponse, header);
257 END_RPC_MESSAGE_RESPONSE;
258END_RPC_MESSAGE_CLASS;
259
260BEGIN_RPC_MESSAGE_CLASS(GetBlockHeaderByHash);
261 BEGIN_RPC_MESSAGE_REQUEST;
262 RPC_MESSAGE_MEMBER(crypto::hash, hash);
263 END_RPC_MESSAGE_REQUEST;
264 BEGIN_RPC_MESSAGE_RESPONSE;
265 RPC_MESSAGE_MEMBER(cryptonote::rpc::BlockHeaderResponse, header);
266 END_RPC_MESSAGE_RESPONSE;
267END_RPC_MESSAGE_CLASS;
268
269BEGIN_RPC_MESSAGE_CLASS(GetBlockHeaderByHeight);
270 BEGIN_RPC_MESSAGE_REQUEST;
271 RPC_MESSAGE_MEMBER(uint64_t, height);
272 END_RPC_MESSAGE_REQUEST;
273 BEGIN_RPC_MESSAGE_RESPONSE;
274 RPC_MESSAGE_MEMBER(cryptonote::rpc::BlockHeaderResponse, header);
275 END_RPC_MESSAGE_RESPONSE;
276END_RPC_MESSAGE_CLASS;
277
278BEGIN_RPC_MESSAGE_CLASS(GetBlockHeadersByHeight);
279 BEGIN_RPC_MESSAGE_REQUEST;
280 RPC_MESSAGE_MEMBER(std::vector<uint64_t>, heights);
281 END_RPC_MESSAGE_REQUEST;
282 BEGIN_RPC_MESSAGE_RESPONSE;
283 RPC_MESSAGE_MEMBER(std::vector<cryptonote::rpc::BlockHeaderResponse>, headers);
284 END_RPC_MESSAGE_RESPONSE;
285END_RPC_MESSAGE_CLASS;
286
287BEGIN_RPC_MESSAGE_CLASS(GetBlock);
288 BEGIN_RPC_MESSAGE_REQUEST;
289 END_RPC_MESSAGE_REQUEST;
290 BEGIN_RPC_MESSAGE_RESPONSE;
291 END_RPC_MESSAGE_RESPONSE;
292END_RPC_MESSAGE_CLASS;
293
294BEGIN_RPC_MESSAGE_CLASS(GetPeerList);
295 BEGIN_RPC_MESSAGE_REQUEST;
296 END_RPC_MESSAGE_REQUEST;
297 BEGIN_RPC_MESSAGE_RESPONSE;
298 RPC_MESSAGE_MEMBER(std::vector<peer>, white_list);
299 RPC_MESSAGE_MEMBER(std::vector<peer>, gray_list);
300 END_RPC_MESSAGE_RESPONSE;
301END_RPC_MESSAGE_CLASS;
302
303BEGIN_RPC_MESSAGE_CLASS(SetLogHashRate);
304 BEGIN_RPC_MESSAGE_REQUEST;
305 END_RPC_MESSAGE_REQUEST;
306 BEGIN_RPC_MESSAGE_RESPONSE;
307 END_RPC_MESSAGE_RESPONSE;
308END_RPC_MESSAGE_CLASS;
309
310BEGIN_RPC_MESSAGE_CLASS(SetLogLevel);
311 BEGIN_RPC_MESSAGE_REQUEST;
312 RPC_MESSAGE_MEMBER(int8_t, level);
313 END_RPC_MESSAGE_REQUEST;
314 BEGIN_RPC_MESSAGE_RESPONSE;
315 END_RPC_MESSAGE_RESPONSE;
316END_RPC_MESSAGE_CLASS;
317
318BEGIN_RPC_MESSAGE_CLASS(GetTransactionPool);
319 BEGIN_RPC_MESSAGE_REQUEST;
320 END_RPC_MESSAGE_REQUEST;
321 BEGIN_RPC_MESSAGE_RESPONSE;
322 RPC_MESSAGE_MEMBER(std::vector<cryptonote::rpc::tx_in_pool>, transactions);
323 RPC_MESSAGE_MEMBER(key_images_with_tx_hashes, key_images);
324 END_RPC_MESSAGE_RESPONSE;
325END_RPC_MESSAGE_CLASS;
326
327BEGIN_RPC_MESSAGE_CLASS(GetConnections);
328 BEGIN_RPC_MESSAGE_REQUEST;
329 END_RPC_MESSAGE_REQUEST;
330 BEGIN_RPC_MESSAGE_RESPONSE;
331 END_RPC_MESSAGE_RESPONSE;
332END_RPC_MESSAGE_CLASS;
333
334BEGIN_RPC_MESSAGE_CLASS(GetBlockHeadersRange);
335 BEGIN_RPC_MESSAGE_REQUEST;
336 END_RPC_MESSAGE_REQUEST;
337 BEGIN_RPC_MESSAGE_RESPONSE;
338 END_RPC_MESSAGE_RESPONSE;
339END_RPC_MESSAGE_CLASS;
340
341BEGIN_RPC_MESSAGE_CLASS(StopDaemon);
342 BEGIN_RPC_MESSAGE_REQUEST;
343 END_RPC_MESSAGE_REQUEST;
344 BEGIN_RPC_MESSAGE_RESPONSE;
345 END_RPC_MESSAGE_RESPONSE;
346END_RPC_MESSAGE_CLASS;
347
348BEGIN_RPC_MESSAGE_CLASS(StartSaveGraph);
349 BEGIN_RPC_MESSAGE_REQUEST;
350 END_RPC_MESSAGE_REQUEST;
351 BEGIN_RPC_MESSAGE_RESPONSE;
352 END_RPC_MESSAGE_RESPONSE;
353END_RPC_MESSAGE_CLASS;
354
355BEGIN_RPC_MESSAGE_CLASS(StopSaveGraph);
356 BEGIN_RPC_MESSAGE_REQUEST;
357 END_RPC_MESSAGE_REQUEST;
358 BEGIN_RPC_MESSAGE_RESPONSE;
359 END_RPC_MESSAGE_RESPONSE;
360END_RPC_MESSAGE_CLASS;
361
362BEGIN_RPC_MESSAGE_CLASS(HardForkInfo);
363 BEGIN_RPC_MESSAGE_REQUEST;
364 RPC_MESSAGE_MEMBER(uint8_t, version);
365 END_RPC_MESSAGE_REQUEST;
366 BEGIN_RPC_MESSAGE_RESPONSE;
367 RPC_MESSAGE_MEMBER(hard_fork_info, info);
368 END_RPC_MESSAGE_RESPONSE;
369END_RPC_MESSAGE_CLASS;
370
371BEGIN_RPC_MESSAGE_CLASS(GetBans);
372 BEGIN_RPC_MESSAGE_REQUEST;
373 END_RPC_MESSAGE_REQUEST;
374 BEGIN_RPC_MESSAGE_RESPONSE;
375 END_RPC_MESSAGE_RESPONSE;
376END_RPC_MESSAGE_CLASS;
377
378BEGIN_RPC_MESSAGE_CLASS(SetBans);
379 BEGIN_RPC_MESSAGE_REQUEST;
380 END_RPC_MESSAGE_REQUEST;
381 BEGIN_RPC_MESSAGE_RESPONSE;
382 END_RPC_MESSAGE_RESPONSE;
383END_RPC_MESSAGE_CLASS;
384
385BEGIN_RPC_MESSAGE_CLASS(FlushTransactionPool);
386 BEGIN_RPC_MESSAGE_REQUEST;
387 END_RPC_MESSAGE_REQUEST;
388 BEGIN_RPC_MESSAGE_RESPONSE;
389 END_RPC_MESSAGE_RESPONSE;
390END_RPC_MESSAGE_CLASS;
391
392BEGIN_RPC_MESSAGE_CLASS(GetOutputHistogram);
393 BEGIN_RPC_MESSAGE_REQUEST;
394 RPC_MESSAGE_MEMBER(std::vector<uint64_t>, amounts);
395 RPC_MESSAGE_MEMBER(uint64_t, min_count);
396 RPC_MESSAGE_MEMBER(uint64_t, max_count);
397 RPC_MESSAGE_MEMBER(bool, unlocked);
398 RPC_MESSAGE_MEMBER(uint64_t, recent_cutoff);
399 END_RPC_MESSAGE_REQUEST;
400 BEGIN_RPC_MESSAGE_RESPONSE;
401 RPC_MESSAGE_MEMBER(std::vector<output_amount_count>, histogram);
402 END_RPC_MESSAGE_RESPONSE;
403END_RPC_MESSAGE_CLASS;
404
405BEGIN_RPC_MESSAGE_CLASS(GetOutputKeys);
406 BEGIN_RPC_MESSAGE_REQUEST;
407 RPC_MESSAGE_MEMBER(std::vector<output_amount_and_index>, outputs);
408 END_RPC_MESSAGE_REQUEST;
409 BEGIN_RPC_MESSAGE_RESPONSE;
410 RPC_MESSAGE_MEMBER(std::vector<output_key_mask_unlocked>, keys);
411 END_RPC_MESSAGE_RESPONSE;
412END_RPC_MESSAGE_CLASS;
413
414BEGIN_RPC_MESSAGE_CLASS(GetRPCVersion);
415 BEGIN_RPC_MESSAGE_REQUEST;
416 END_RPC_MESSAGE_REQUEST;
417 BEGIN_RPC_MESSAGE_RESPONSE;
418 RPC_MESSAGE_MEMBER(uint32_t, version);
419 END_RPC_MESSAGE_RESPONSE;
420END_RPC_MESSAGE_CLASS;
421
422BEGIN_RPC_MESSAGE_CLASS(GetFeeEstimate);
423 BEGIN_RPC_MESSAGE_REQUEST;
424 RPC_MESSAGE_MEMBER(uint64_t, num_grace_blocks);
425 END_RPC_MESSAGE_REQUEST;
426 BEGIN_RPC_MESSAGE_RESPONSE;
427 RPC_MESSAGE_MEMBER(std::vector<uint64_t>, fees);
428 RPC_MESSAGE_MEMBER(uint64_t, estimated_base_fee);
429 RPC_MESSAGE_MEMBER(uint64_t, fee_mask);
430 RPC_MESSAGE_MEMBER(uint32_t, size_scale);
431 RPC_MESSAGE_MEMBER(uint8_t, hard_fork_version);
432 END_RPC_MESSAGE_RESPONSE;
433END_RPC_MESSAGE_CLASS;
434
435BEGIN_RPC_MESSAGE_CLASS(GetOutputDistribution);
436 BEGIN_RPC_MESSAGE_REQUEST;
437 RPC_MESSAGE_MEMBER(std::vector<uint64_t>, amounts);
438 RPC_MESSAGE_MEMBER(uint64_t, from_height);
439 RPC_MESSAGE_MEMBER(uint64_t, to_height);
440 RPC_MESSAGE_MEMBER(bool, cumulative);
441 END_RPC_MESSAGE_REQUEST;
442 BEGIN_RPC_MESSAGE_RESPONSE;
443 RPC_MESSAGE_MEMBER(std::vector<output_distribution>, distributions);
444 END_RPC_MESSAGE_RESPONSE;
445END_RPC_MESSAGE_CLASS;
446
447} // namespace rpc
448
449} // namespace cryptonote
prune
static void prune(MDB_env *env0, MDB_env *env1)
Definition blockchain_prune.cpp:249
fees
static boost::multiprecision::uint128_t fees
Definition blockchain_stats.cpp:58
byte_stream.h
cryptonote::transaction
Definition cryptonote_basic.h:205
outputs
std::tuple< uint64_t, uint64_t, std::vector< tools::wallet2::transfer_details > > outputs
Definition cold-outputs.cpp:53
cryptonote_basic.h
cryptonote_protocol_defs.h
BEGIN_RPC_MESSAGE_CLASS
#define BEGIN_RPC_MESSAGE_CLASS(classname)
Definition daemon_messages.h:42
BEGIN_RPC_MESSAGE_REQUEST
#define BEGIN_RPC_MESSAGE_REQUEST
Definition daemon_messages.h:47
RPC_MESSAGE_MEMBER
#define RPC_MESSAGE_MEMBER(type, name)
Definition daemon_messages.h:72
daemon_rpc_version.h
info
static MDB_envinfo info
Definition mdb_load.c:37
version
static int version
Definition mdb_load.c:29
message_data_structs.h
address
uint32_t address
Definition getifaddr.c:269
blocks
Definition blocks.cpp:13
crypto::hash
POD_CLASS hash
Definition hash.h:49
cryptonote::rpc::END_RPC_MESSAGE_CLASS
END_RPC_MESSAGE_CLASS
Definition daemon_messages.h:87
cryptonote::rpc::Response
SendRawTx::Response Response
Definition daemon_messages.h:181
cryptonote::rpc::END_RPC_MESSAGE_REQUEST
END_RPC_MESSAGE_REQUEST
Definition daemon_messages.h:83
cryptonote::rpc::BEGIN_RPC_MESSAGE_RESPONSE
BEGIN_RPC_MESSAGE_RESPONSE
Definition daemon_messages.h:84
cryptonote::rpc::BEGIN_RPC_MESSAGE_REQUEST
BEGIN_RPC_MESSAGE_REQUEST
Definition daemon_messages.h:82
cryptonote::rpc::END_RPC_MESSAGE_RESPONSE
END_RPC_MESSAGE_RESPONSE
Definition daemon_messages.h:86
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::STATUS
STATUS
Definition daemon_messages.h:132
cryptonote::rpc::SPENT_IN_POOL
@ SPENT_IN_POOL
Definition daemon_messages.h:135
cryptonote::rpc::SPENT_IN_BLOCKCHAIN
@ SPENT_IN_BLOCKCHAIN
Definition daemon_messages.h:134
cryptonote::rpc::UNSPENT
@ UNSPENT
Definition daemon_messages.h:133
cryptonote::rpc::txes_map
std::unordered_map< crypto::hash, transaction_info > txes_map
Definition daemon_messages.h:124
cryptonote
Holds cryptonote related classes and helpers.
Definition blockchain_db.cpp:45
speed
Definition speed.py:1
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::BlockHeaderResponse
Definition message_data_structs.h:161
cryptonote::rpc::DaemonInfo
Definition message_data_structs.h:176
cryptonote::rpc::hard_fork_info
Definition message_data_structs.h:131
header
Definition minissdpd.c:66
hashes
struct hash_func hashes[]
tx
cryptonote::transaction tx
Definition transaction.cpp:40
Generated on for Monero by doxygen 1.16.1