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 END_RPC_MESSAGE_RESPONSE;
102END_RPC_MESSAGE_CLASS;
103
104
105BEGIN_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;
115END_RPC_MESSAGE_CLASS;
116
117
118BEGIN_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;
127END_RPC_MESSAGE_CLASS;
128
129
130BEGIN_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;
142END_RPC_MESSAGE_CLASS;
143
144
145BEGIN_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;
152END_RPC_MESSAGE_CLASS;
153
154
155BEGIN_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;
163END_RPC_MESSAGE_CLASS;
164
165BEGIN_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;
173END_RPC_MESSAGE_CLASS;
174
175BEGIN_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;
181END_RPC_MESSAGE_CLASS;
182
183BEGIN_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;
192END_RPC_MESSAGE_CLASS;
193
194BEGIN_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;
200END_RPC_MESSAGE_CLASS;
201
202BEGIN_RPC_MESSAGE_CLASS(StopMining);
203 BEGIN_RPC_MESSAGE_REQUEST;
204 END_RPC_MESSAGE_REQUEST;
205 BEGIN_RPC_MESSAGE_RESPONSE;
206 END_RPC_MESSAGE_RESPONSE;
207END_RPC_MESSAGE_CLASS;
208
209BEGIN_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;
219END_RPC_MESSAGE_CLASS;
220
221BEGIN_RPC_MESSAGE_CLASS(SaveBC);
222 BEGIN_RPC_MESSAGE_REQUEST;
223 END_RPC_MESSAGE_REQUEST;
224 BEGIN_RPC_MESSAGE_RESPONSE;
225 END_RPC_MESSAGE_RESPONSE;
226END_RPC_MESSAGE_CLASS;
227
228BEGIN_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;
235END_RPC_MESSAGE_CLASS;
236
237BEGIN_RPC_MESSAGE_CLASS(GetBlockTemplate);
238 BEGIN_RPC_MESSAGE_REQUEST;
239 END_RPC_MESSAGE_REQUEST;
240 BEGIN_RPC_MESSAGE_RESPONSE;
241 END_RPC_MESSAGE_RESPONSE;
242END_RPC_MESSAGE_CLASS;
243
244BEGIN_RPC_MESSAGE_CLASS(SubmitBlock);
245 BEGIN_RPC_MESSAGE_REQUEST;
246 END_RPC_MESSAGE_REQUEST;
247 BEGIN_RPC_MESSAGE_RESPONSE;
248 END_RPC_MESSAGE_RESPONSE;
249END_RPC_MESSAGE_CLASS;
250
251BEGIN_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;
257END_RPC_MESSAGE_CLASS;
258
259BEGIN_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;
266END_RPC_MESSAGE_CLASS;
267
268BEGIN_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;
275END_RPC_MESSAGE_CLASS;
276
277BEGIN_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;
284END_RPC_MESSAGE_CLASS;
285
286BEGIN_RPC_MESSAGE_CLASS(GetBlock);
287 BEGIN_RPC_MESSAGE_REQUEST;
288 END_RPC_MESSAGE_REQUEST;
289 BEGIN_RPC_MESSAGE_RESPONSE;
290 END_RPC_MESSAGE_RESPONSE;
291END_RPC_MESSAGE_CLASS;
292
293BEGIN_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;
300END_RPC_MESSAGE_CLASS;
301
302BEGIN_RPC_MESSAGE_CLASS(SetLogHashRate);
303 BEGIN_RPC_MESSAGE_REQUEST;
304 END_RPC_MESSAGE_REQUEST;
305 BEGIN_RPC_MESSAGE_RESPONSE;
306 END_RPC_MESSAGE_RESPONSE;
307END_RPC_MESSAGE_CLASS;
308
309BEGIN_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;
315END_RPC_MESSAGE_CLASS;
316
317BEGIN_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;
324END_RPC_MESSAGE_CLASS;
325
326BEGIN_RPC_MESSAGE_CLASS(GetConnections);
327 BEGIN_RPC_MESSAGE_REQUEST;
328 END_RPC_MESSAGE_REQUEST;
329 BEGIN_RPC_MESSAGE_RESPONSE;
330 END_RPC_MESSAGE_RESPONSE;
331END_RPC_MESSAGE_CLASS;
332
333BEGIN_RPC_MESSAGE_CLASS(GetBlockHeadersRange);
334 BEGIN_RPC_MESSAGE_REQUEST;
335 END_RPC_MESSAGE_REQUEST;
336 BEGIN_RPC_MESSAGE_RESPONSE;
337 END_RPC_MESSAGE_RESPONSE;
338END_RPC_MESSAGE_CLASS;
339
340BEGIN_RPC_MESSAGE_CLASS(StopDaemon);
341 BEGIN_RPC_MESSAGE_REQUEST;
342 END_RPC_MESSAGE_REQUEST;
343 BEGIN_RPC_MESSAGE_RESPONSE;
344 END_RPC_MESSAGE_RESPONSE;
345END_RPC_MESSAGE_CLASS;
346
347BEGIN_RPC_MESSAGE_CLASS(StartSaveGraph);
348 BEGIN_RPC_MESSAGE_REQUEST;
349 END_RPC_MESSAGE_REQUEST;
350 BEGIN_RPC_MESSAGE_RESPONSE;
351 END_RPC_MESSAGE_RESPONSE;
352END_RPC_MESSAGE_CLASS;
353
354BEGIN_RPC_MESSAGE_CLASS(StopSaveGraph);
355 BEGIN_RPC_MESSAGE_REQUEST;
356 END_RPC_MESSAGE_REQUEST;
357 BEGIN_RPC_MESSAGE_RESPONSE;
358 END_RPC_MESSAGE_RESPONSE;
359END_RPC_MESSAGE_CLASS;
360
361BEGIN_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;
368END_RPC_MESSAGE_CLASS;
369
370BEGIN_RPC_MESSAGE_CLASS(GetBans);
371 BEGIN_RPC_MESSAGE_REQUEST;
372 END_RPC_MESSAGE_REQUEST;
373 BEGIN_RPC_MESSAGE_RESPONSE;
374 END_RPC_MESSAGE_RESPONSE;
375END_RPC_MESSAGE_CLASS;
376
377BEGIN_RPC_MESSAGE_CLASS(SetBans);
378 BEGIN_RPC_MESSAGE_REQUEST;
379 END_RPC_MESSAGE_REQUEST;
380 BEGIN_RPC_MESSAGE_RESPONSE;
381 END_RPC_MESSAGE_RESPONSE;
382END_RPC_MESSAGE_CLASS;
383
384BEGIN_RPC_MESSAGE_CLASS(FlushTransactionPool);
385 BEGIN_RPC_MESSAGE_REQUEST;
386 END_RPC_MESSAGE_REQUEST;
387 BEGIN_RPC_MESSAGE_RESPONSE;
388 END_RPC_MESSAGE_RESPONSE;
389END_RPC_MESSAGE_CLASS;
390
391BEGIN_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;
402END_RPC_MESSAGE_CLASS;
403
404BEGIN_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;
411END_RPC_MESSAGE_CLASS;
412
413BEGIN_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;
419END_RPC_MESSAGE_CLASS;
420
421BEGIN_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;
431END_RPC_MESSAGE_CLASS;
432
433BEGIN_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;
443END_RPC_MESSAGE_CLASS;
444
445} // namespace rpc
446
447} // namespace cryptonote
prune
static void prune(MDB_env *env0, MDB_env *env1)
Definition: blockchain_prune.cpp:249
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
RPC_MESSAGE_MEMBER
#define RPC_MESSAGE_MEMBER(type, name)
Definition: daemon_messages.h:72
daemon_rpc_version.h
count
int * count
Definition: gmock_stress_test.cc:176
active
epee::byte_slice active
Definition: levin_notify.cpp:255
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:48
cryptonote::rpc::END_RPC_MESSAGE_CLASS
END_RPC_MESSAGE_CLASS
Definition: daemon_messages.h:87
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::Response
SendRawTx::Response Response
Definition: daemon_messages.h:180
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:131
cryptonote::rpc::SPENT_IN_POOL
@ SPENT_IN_POOL
Definition: daemon_messages.h:134
cryptonote::rpc::SPENT_IN_BLOCKCHAIN
@ SPENT_IN_BLOCKCHAIN
Definition: daemon_messages.h:133
cryptonote::rpc::UNSPENT
@ UNSPENT
Definition: daemon_messages.h:132
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
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
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 Sat Feb 18 2023 00:00:00 for Monero by doxygen 1.9.6