2015-12-31 06:39:56 +00:00
|
|
|
// Copyright (c) 2014-2016, The Monero Project
|
2014-07-23 13:03:52 +00:00
|
|
|
//
|
|
|
|
// All rights reserved.
|
|
|
|
//
|
|
|
|
// Redistribution and use in source and binary forms, with or without modification, are
|
|
|
|
// permitted provided that the following conditions are met:
|
|
|
|
//
|
|
|
|
// 1. Redistributions of source code must retain the above copyright notice, this list of
|
|
|
|
// conditions and the following disclaimer.
|
|
|
|
//
|
|
|
|
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
|
|
|
// of conditions and the following disclaimer in the documentation and/or other
|
|
|
|
// materials provided with the distribution.
|
|
|
|
//
|
|
|
|
// 3. Neither the name of the copyright holder nor the names of its contributors may be
|
|
|
|
// used to endorse or promote products derived from this software without specific
|
|
|
|
// prior written permission.
|
|
|
|
//
|
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
|
|
|
|
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
|
|
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
|
|
|
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
|
|
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
|
|
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
|
|
|
|
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
//
|
|
|
|
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
|
2014-04-02 16:00:17 +00:00
|
|
|
|
|
|
|
#pragma once
|
|
|
|
#include "cryptonote_protocol/cryptonote_protocol_defs.h"
|
|
|
|
#include "cryptonote_core/cryptonote_basic.h"
|
|
|
|
#include "crypto/hash.h"
|
|
|
|
#include "wallet_rpc_server_error_codes.h"
|
Change logging to easylogging++
This replaces the epee and data_loggers logging systems with
a single one, and also adds filename:line and explicit severity
levels. Categories may be defined, and logging severity set
by category (or set of categories). epee style 0-4 log level
maps to a sensible severity configuration. Log files now also
rotate when reaching 100 MB.
To select which logs to output, use the MONERO_LOGS environment
variable, with a comma separated list of categories (globs are
supported), with their requested severity level after a colon.
If a log matches more than one such setting, the last one in
the configuration string applies. A few examples:
This one is (mostly) silent, only outputting fatal errors:
MONERO_LOGS=*:FATAL
This one is very verbose:
MONERO_LOGS=*:TRACE
This one is totally silent (logwise):
MONERO_LOGS=""
This one outputs all errors and warnings, except for the
"verify" category, which prints just fatal errors (the verify
category is used for logs about incoming transactions and
blocks, and it is expected that some/many will fail to verify,
hence we don't want the spam):
MONERO_LOGS=*:WARNING,verify:FATAL
Log levels are, in decreasing order of priority:
FATAL, ERROR, WARNING, INFO, DEBUG, TRACE
Subcategories may be added using prefixes and globs. This
example will output net.p2p logs at the TRACE level, but all
other net* logs only at INFO:
MONERO_LOGS=*:ERROR,net*:INFO,net.p2p:TRACE
Logs which are intended for the user (which Monero was using
a lot through epee, but really isn't a nice way to go things)
should use the "global" category. There are a few helper macros
for using this category, eg: MGINFO("this shows up by default")
or MGINFO_RED("this is red"), to try to keep a similar look
and feel for now.
Existing epee log macros still exist, and map to the new log
levels, but since they're used as a "user facing" UI element
as much as a logging system, they often don't map well to log
severities (ie, a log level 0 log may be an error, or may be
something we want the user to see, such as an important info).
In those cases, I tried to use the new macros. In other cases,
I left the existing macros in. When modifying logs, it is
probably best to switch to the new macros with explicit levels.
The --log-level options and set_log commands now also accept
category settings, in addition to the epee style log levels.
2017-01-01 16:34:23 +00:00
|
|
|
|
|
|
|
#undef MONERO_DEFAULT_LOG_CATEGORY
|
|
|
|
#define MONERO_DEFAULT_LOG_CATEGORY "wallet.rpc"
|
|
|
|
|
2014-04-02 16:00:17 +00:00
|
|
|
namespace tools
|
|
|
|
{
|
|
|
|
namespace wallet_rpc
|
|
|
|
{
|
|
|
|
#define WALLET_RPC_STATUS_OK "OK"
|
|
|
|
#define WALLET_RPC_STATUS_BUSY "BUSY"
|
|
|
|
|
|
|
|
struct COMMAND_RPC_GET_BALANCE
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
uint64_t balance;
|
|
|
|
uint64_t unlocked_balance;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(balance)
|
|
|
|
KV_SERIALIZE(unlocked_balance)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2014-05-24 22:20:46 +00:00
|
|
|
struct COMMAND_RPC_GET_ADDRESS
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
std::string address;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(address)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2015-12-23 16:04:04 +00:00
|
|
|
struct COMMAND_RPC_GET_HEIGHT
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
2015-12-23 19:10:59 +00:00
|
|
|
uint64_t height;
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(height)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
2015-12-23 16:04:04 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2014-06-17 22:15:21 +00:00
|
|
|
struct transfer_destination
|
2014-04-02 16:00:17 +00:00
|
|
|
{
|
|
|
|
uint64_t amount;
|
|
|
|
std::string address;
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(amount)
|
|
|
|
KV_SERIALIZE(address)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct COMMAND_RPC_TRANSFER
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
2014-06-17 22:15:21 +00:00
|
|
|
std::list<transfer_destination> destinations;
|
2016-09-16 10:50:52 +00:00
|
|
|
uint32_t priority;
|
2014-04-02 16:00:17 +00:00
|
|
|
uint64_t mixin;
|
|
|
|
uint64_t unlock_time;
|
2014-06-01 22:22:42 +00:00
|
|
|
std::string payment_id;
|
2015-08-19 19:59:44 +00:00
|
|
|
bool get_tx_key;
|
2016-04-02 12:06:39 +00:00
|
|
|
bool trusted_daemon;
|
2014-04-02 16:00:17 +00:00
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(destinations)
|
2016-09-16 10:50:52 +00:00
|
|
|
KV_SERIALIZE(priority)
|
2014-04-02 16:00:17 +00:00
|
|
|
KV_SERIALIZE(mixin)
|
|
|
|
KV_SERIALIZE(unlock_time)
|
2014-06-01 22:22:42 +00:00
|
|
|
KV_SERIALIZE(payment_id)
|
2015-08-19 19:59:44 +00:00
|
|
|
KV_SERIALIZE(get_tx_key)
|
2016-04-02 12:06:39 +00:00
|
|
|
KV_SERIALIZE(trusted_daemon)
|
2014-04-02 16:00:17 +00:00
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
std::string tx_hash;
|
2015-08-19 19:59:44 +00:00
|
|
|
std::string tx_key;
|
2016-07-11 22:14:58 +00:00
|
|
|
std::list<std::string> amount_keys;
|
2016-11-16 18:56:45 +00:00
|
|
|
uint64_t fee;
|
2014-04-02 16:00:17 +00:00
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(tx_hash)
|
2015-08-19 19:59:44 +00:00
|
|
|
KV_SERIALIZE(tx_key)
|
2016-07-11 22:14:58 +00:00
|
|
|
KV_SERIALIZE(amount_keys)
|
2016-11-16 18:56:45 +00:00
|
|
|
KV_SERIALIZE(fee)
|
2014-04-02 16:00:17 +00:00
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2014-06-17 22:15:21 +00:00
|
|
|
struct COMMAND_RPC_TRANSFER_SPLIT
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
std::list<transfer_destination> destinations;
|
2016-09-16 10:50:52 +00:00
|
|
|
uint32_t priority;
|
2014-06-17 22:15:21 +00:00
|
|
|
uint64_t mixin;
|
|
|
|
uint64_t unlock_time;
|
|
|
|
std::string payment_id;
|
2015-08-19 19:59:44 +00:00
|
|
|
bool get_tx_keys;
|
2016-04-02 12:06:39 +00:00
|
|
|
bool trusted_daemon;
|
2014-06-17 22:15:21 +00:00
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(destinations)
|
2016-09-16 10:50:52 +00:00
|
|
|
KV_SERIALIZE(priority)
|
2014-06-17 22:15:21 +00:00
|
|
|
KV_SERIALIZE(mixin)
|
|
|
|
KV_SERIALIZE(unlock_time)
|
|
|
|
KV_SERIALIZE(payment_id)
|
2015-08-19 19:59:44 +00:00
|
|
|
KV_SERIALIZE(get_tx_keys)
|
2016-04-02 12:06:39 +00:00
|
|
|
KV_SERIALIZE(trusted_daemon)
|
2014-06-17 22:15:21 +00:00
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
2016-07-11 22:14:58 +00:00
|
|
|
struct key_list
|
|
|
|
{
|
|
|
|
std::list<std::string> keys;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(keys)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
2014-06-17 22:15:21 +00:00
|
|
|
struct response
|
|
|
|
{
|
|
|
|
std::list<std::string> tx_hash_list;
|
2015-08-19 19:59:44 +00:00
|
|
|
std::list<std::string> tx_key_list;
|
2016-11-16 18:56:45 +00:00
|
|
|
std::list<uint64_t> fee_list;
|
2014-06-17 22:15:21 +00:00
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(tx_hash_list)
|
2015-08-19 19:59:44 +00:00
|
|
|
KV_SERIALIZE(tx_key_list)
|
2016-11-16 18:56:45 +00:00
|
|
|
KV_SERIALIZE(fee_list)
|
2014-06-17 22:15:21 +00:00
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2015-05-30 14:37:27 +00:00
|
|
|
struct COMMAND_RPC_SWEEP_DUST
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
2015-08-19 19:59:44 +00:00
|
|
|
bool get_tx_keys;
|
2016-03-26 23:22:57 +00:00
|
|
|
bool trusted_daemon;
|
2015-08-19 19:59:44 +00:00
|
|
|
|
2015-05-30 14:37:27 +00:00
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
2015-08-19 19:59:44 +00:00
|
|
|
KV_SERIALIZE(get_tx_keys)
|
2016-03-26 23:22:57 +00:00
|
|
|
KV_SERIALIZE(trusted_daemon)
|
2015-05-30 14:37:27 +00:00
|
|
|
END_KV_SERIALIZE_MAP()
|
2016-04-19 20:20:27 +00:00
|
|
|
};
|
|
|
|
|
2016-07-11 22:14:58 +00:00
|
|
|
struct key_list
|
|
|
|
{
|
|
|
|
std::list<std::string> keys;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(keys)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
2016-04-19 20:20:27 +00:00
|
|
|
struct response
|
|
|
|
{
|
|
|
|
std::list<std::string> tx_hash_list;
|
|
|
|
std::list<std::string> tx_key_list;
|
2016-11-16 18:56:45 +00:00
|
|
|
std::list<uint64_t> fee_list;
|
2016-04-19 20:20:27 +00:00
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(tx_hash_list)
|
|
|
|
KV_SERIALIZE(tx_key_list)
|
2016-11-16 18:56:45 +00:00
|
|
|
KV_SERIALIZE(fee_list)
|
2016-04-19 20:20:27 +00:00
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
struct COMMAND_RPC_SWEEP_ALL
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
std::string address;
|
2016-09-16 10:50:52 +00:00
|
|
|
uint32_t priority;
|
2016-04-19 20:20:27 +00:00
|
|
|
uint64_t mixin;
|
|
|
|
uint64_t unlock_time;
|
|
|
|
std::string payment_id;
|
|
|
|
bool get_tx_keys;
|
|
|
|
bool trusted_daemon;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(address)
|
2016-09-16 10:50:52 +00:00
|
|
|
KV_SERIALIZE(priority)
|
2016-04-19 20:20:27 +00:00
|
|
|
KV_SERIALIZE(mixin)
|
|
|
|
KV_SERIALIZE(unlock_time)
|
|
|
|
KV_SERIALIZE(payment_id)
|
|
|
|
KV_SERIALIZE(get_tx_keys)
|
|
|
|
KV_SERIALIZE(trusted_daemon)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
2015-05-30 14:37:27 +00:00
|
|
|
};
|
|
|
|
|
2016-07-11 22:14:58 +00:00
|
|
|
struct key_list
|
|
|
|
{
|
|
|
|
std::list<std::string> keys;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(keys)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
2015-05-30 14:37:27 +00:00
|
|
|
struct response
|
|
|
|
{
|
|
|
|
std::list<std::string> tx_hash_list;
|
2015-08-19 19:59:44 +00:00
|
|
|
std::list<std::string> tx_key_list;
|
2016-11-16 18:56:45 +00:00
|
|
|
std::list<uint64_t> fee_list;
|
2015-05-30 14:37:27 +00:00
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(tx_hash_list)
|
2015-08-19 19:59:44 +00:00
|
|
|
KV_SERIALIZE(tx_key_list)
|
2016-11-16 18:56:45 +00:00
|
|
|
KV_SERIALIZE(fee_list)
|
2015-05-30 14:37:27 +00:00
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2014-04-02 16:00:17 +00:00
|
|
|
struct COMMAND_RPC_STORE
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2014-05-03 16:19:43 +00:00
|
|
|
struct payment_details
|
|
|
|
{
|
2014-07-22 16:00:25 +00:00
|
|
|
std::string payment_id;
|
2014-05-03 16:19:43 +00:00
|
|
|
std::string tx_hash;
|
|
|
|
uint64_t amount;
|
|
|
|
uint64_t block_height;
|
|
|
|
uint64_t unlock_time;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
2014-07-22 16:00:25 +00:00
|
|
|
KV_SERIALIZE(payment_id)
|
2014-05-03 16:19:43 +00:00
|
|
|
KV_SERIALIZE(tx_hash)
|
|
|
|
KV_SERIALIZE(amount)
|
|
|
|
KV_SERIALIZE(block_height)
|
|
|
|
KV_SERIALIZE(unlock_time)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct COMMAND_RPC_GET_PAYMENTS
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
std::string payment_id;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(payment_id)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
std::list<payment_details> payments;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(payments)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
2014-07-22 16:00:25 +00:00
|
|
|
|
|
|
|
struct COMMAND_RPC_GET_BULK_PAYMENTS
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
std::vector<std::string> payment_ids;
|
|
|
|
uint64_t min_block_height;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(payment_ids)
|
|
|
|
KV_SERIALIZE(min_block_height)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
std::list<payment_details> payments;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(payments)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
2014-05-27 10:52:11 +00:00
|
|
|
|
|
|
|
struct transfer_details
|
|
|
|
{
|
|
|
|
uint64_t amount;
|
|
|
|
bool spent;
|
|
|
|
uint64_t global_index;
|
|
|
|
std::string tx_hash;
|
2015-02-19 22:57:26 +00:00
|
|
|
uint64_t tx_size;
|
2014-05-27 10:52:11 +00:00
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(amount)
|
|
|
|
KV_SERIALIZE(spent)
|
|
|
|
KV_SERIALIZE(global_index)
|
|
|
|
KV_SERIALIZE(tx_hash)
|
2015-02-19 22:57:26 +00:00
|
|
|
KV_SERIALIZE(tx_size)
|
2014-05-27 10:52:11 +00:00
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct COMMAND_RPC_INCOMING_TRANSFERS
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
std::string transfer_type;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(transfer_type)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
std::list<transfer_details> transfers;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(transfers)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
2014-08-05 06:17:23 +00:00
|
|
|
|
|
|
|
//JSON RPC V2
|
|
|
|
struct COMMAND_RPC_QUERY_KEY
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
std::string key_type;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(key_type)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
std::string key;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(key)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
2015-06-13 15:08:00 +00:00
|
|
|
|
|
|
|
struct COMMAND_RPC_MAKE_INTEGRATED_ADDRESS
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
std::string payment_id;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(payment_id)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
std::string integrated_address;
|
2016-08-29 11:18:22 +00:00
|
|
|
std::string payment_id;
|
2015-06-13 15:08:00 +00:00
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(integrated_address)
|
2016-08-29 11:18:22 +00:00
|
|
|
KV_SERIALIZE(payment_id)
|
2015-06-13 15:08:00 +00:00
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
struct COMMAND_RPC_SPLIT_INTEGRATED_ADDRESS
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
std::string integrated_address;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(integrated_address)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
std::string standard_address;
|
|
|
|
std::string payment_id;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(standard_address)
|
|
|
|
KV_SERIALIZE(payment_id)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2015-12-05 14:53:37 +00:00
|
|
|
struct COMMAND_RPC_STOP_WALLET
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2015-12-30 12:58:15 +00:00
|
|
|
struct COMMAND_RPC_RESCAN_BLOCKCHAIN
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2016-04-20 17:19:42 +00:00
|
|
|
struct COMMAND_RPC_SET_TX_NOTES
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
std::list<std::string> txids;
|
|
|
|
std::list<std::string> notes;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(txids)
|
|
|
|
KV_SERIALIZE(notes)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
struct COMMAND_RPC_GET_TX_NOTES
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
std::list<std::string> txids;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(txids)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
std::list<std::string> notes;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(notes)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2017-01-08 13:16:22 +00:00
|
|
|
struct transfer_entry
|
|
|
|
{
|
|
|
|
std::string txid;
|
|
|
|
std::string payment_id;
|
|
|
|
uint64_t height;
|
|
|
|
uint64_t timestamp;
|
|
|
|
uint64_t amount;
|
|
|
|
uint64_t fee;
|
|
|
|
std::string note;
|
|
|
|
std::list<transfer_destination> destinations;
|
|
|
|
std::string type;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(txid);
|
|
|
|
KV_SERIALIZE(payment_id);
|
|
|
|
KV_SERIALIZE(height);
|
|
|
|
KV_SERIALIZE(timestamp);
|
|
|
|
KV_SERIALIZE(amount);
|
|
|
|
KV_SERIALIZE(fee);
|
|
|
|
KV_SERIALIZE(note);
|
|
|
|
KV_SERIALIZE(destinations);
|
|
|
|
KV_SERIALIZE(type);
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
2016-04-26 21:39:08 +00:00
|
|
|
struct COMMAND_RPC_GET_TRANSFERS
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
bool in;
|
|
|
|
bool out;
|
|
|
|
bool pending;
|
|
|
|
bool failed;
|
2016-05-23 20:40:12 +00:00
|
|
|
bool pool;
|
2016-04-27 22:43:39 +00:00
|
|
|
|
|
|
|
bool filter_by_height;
|
2016-04-26 21:39:08 +00:00
|
|
|
uint64_t min_height;
|
|
|
|
uint64_t max_height;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(in);
|
|
|
|
KV_SERIALIZE(out);
|
|
|
|
KV_SERIALIZE(pending);
|
|
|
|
KV_SERIALIZE(failed);
|
2016-05-23 20:40:12 +00:00
|
|
|
KV_SERIALIZE(pool);
|
2016-04-27 22:43:39 +00:00
|
|
|
KV_SERIALIZE(filter_by_height);
|
2016-04-26 21:39:08 +00:00
|
|
|
KV_SERIALIZE(min_height);
|
|
|
|
KV_SERIALIZE(max_height);
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
2017-01-08 13:16:22 +00:00
|
|
|
struct response
|
|
|
|
{
|
|
|
|
std::list<transfer_entry> in;
|
|
|
|
std::list<transfer_entry> out;
|
|
|
|
std::list<transfer_entry> pending;
|
|
|
|
std::list<transfer_entry> failed;
|
|
|
|
std::list<transfer_entry> pool;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(in);
|
|
|
|
KV_SERIALIZE(out);
|
|
|
|
KV_SERIALIZE(pending);
|
|
|
|
KV_SERIALIZE(failed);
|
|
|
|
KV_SERIALIZE(pool);
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
struct COMMAND_RPC_GET_TRANSFER_BY_TXID
|
|
|
|
{
|
|
|
|
struct request
|
2016-04-26 21:39:08 +00:00
|
|
|
{
|
|
|
|
std::string txid;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(txid);
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
2017-01-08 13:16:22 +00:00
|
|
|
transfer_entry transfer;
|
2016-04-26 21:39:08 +00:00
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
2017-01-08 13:16:22 +00:00
|
|
|
KV_SERIALIZE(transfer);
|
2016-04-26 21:39:08 +00:00
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2016-04-23 20:46:48 +00:00
|
|
|
struct COMMAND_RPC_SIGN
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
std::string data;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(data);
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
std::string signature;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(signature);
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
struct COMMAND_RPC_VERIFY
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
std::string data;
|
|
|
|
std::string address;
|
|
|
|
std::string signature;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(data);
|
|
|
|
KV_SERIALIZE(address);
|
|
|
|
KV_SERIALIZE(signature);
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
bool good;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(good);
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2016-07-15 11:11:55 +00:00
|
|
|
struct COMMAND_RPC_EXPORT_KEY_IMAGES
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct signed_key_image
|
|
|
|
{
|
|
|
|
std::string key_image;
|
|
|
|
std::string signature;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(key_image);
|
|
|
|
KV_SERIALIZE(signature);
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
std::vector<signed_key_image> signed_key_images;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(signed_key_images);
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
struct COMMAND_RPC_IMPORT_KEY_IMAGES
|
|
|
|
{
|
|
|
|
struct signed_key_image
|
|
|
|
{
|
|
|
|
std::string key_image;
|
|
|
|
std::string signature;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(key_image);
|
|
|
|
KV_SERIALIZE(signature);
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
std::vector<signed_key_image> signed_key_images;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(signed_key_images);
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
uint64_t height;
|
|
|
|
uint64_t spent;
|
|
|
|
uint64_t unspent;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(height)
|
|
|
|
KV_SERIALIZE(spent)
|
|
|
|
KV_SERIALIZE(unspent)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2016-11-28 14:07:25 +00:00
|
|
|
struct uri_spec
|
|
|
|
{
|
|
|
|
std::string address;
|
|
|
|
std::string payment_id;
|
|
|
|
uint64_t amount;
|
|
|
|
std::string tx_description;
|
|
|
|
std::string recipient_name;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(address);
|
|
|
|
KV_SERIALIZE(payment_id);
|
|
|
|
KV_SERIALIZE(amount);
|
|
|
|
KV_SERIALIZE(tx_description);
|
|
|
|
KV_SERIALIZE(recipient_name);
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct COMMAND_RPC_MAKE_URI
|
|
|
|
{
|
|
|
|
struct request: public uri_spec
|
|
|
|
{
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
std::string uri;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(uri)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
struct COMMAND_RPC_PARSE_URI
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
std::string uri;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(uri)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
uri_spec uri;
|
|
|
|
std::vector<std::string> unknown_parameters;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(uri);
|
|
|
|
KV_SERIALIZE(unknown_parameters);
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2017-02-04 11:40:49 +00:00
|
|
|
struct COMMAND_RPC_ADD_ADDRESS_BOOK_ENTRY
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
std::string address;
|
|
|
|
std::string payment_id;
|
|
|
|
std::string description;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(address)
|
|
|
|
KV_SERIALIZE(payment_id)
|
|
|
|
KV_SERIALIZE(description)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
uint64_t index;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(index);
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
struct COMMAND_RPC_GET_ADDRESS_BOOK_ENTRY
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
std::list<uint64_t> entries;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(entries)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct entry
|
|
|
|
{
|
|
|
|
uint64_t index;
|
|
|
|
std::string address;
|
|
|
|
std::string payment_id;
|
|
|
|
std::string description;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(index)
|
|
|
|
KV_SERIALIZE(address)
|
|
|
|
KV_SERIALIZE(payment_id)
|
|
|
|
KV_SERIALIZE(description)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
std::vector<entry> entries;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(entries)
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
struct COMMAND_RPC_DELETE_ADDRESS_BOOK_ENTRY
|
|
|
|
{
|
|
|
|
struct request
|
|
|
|
{
|
|
|
|
uint64_t index;
|
|
|
|
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
KV_SERIALIZE(index);
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
|
|
|
|
struct response
|
|
|
|
{
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
|
|
END_KV_SERIALIZE_MAP()
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2014-04-02 16:00:17 +00:00
|
|
|
}
|
|
|
|
}
|