monero/src/wallet/wallet_rpc_server_commands_defs.h

1979 lines
41 KiB
C
Raw Normal View History

2018-01-07 05:05:16 +00:00
// Copyright (c) 2014-2018, 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_config.h"
2014-04-02 16:00:17 +00:00
#include "cryptonote_protocol/cryptonote_protocol_defs.h"
#include "cryptonote_basic/cryptonote_basic.h"
2017-02-19 02:42:10 +00:00
#include "cryptonote_basic/subaddress_index.h"
2014-04-02 16:00:17 +00:00
#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"
// When making *any* change here, bump minor
// If the change is incompatible, then bump major and set minor to 0
// This ensures WALLET_RPC_VERSION always increases, that every change
// has its own version, and that clients can just test major to see
// whether they can talk to a given wallet without having to know in
// advance which version they will stop working with
// Don't go over 32767 for any of these
#define WALLET_RPC_VERSION_MAJOR 1
#define WALLET_RPC_VERSION_MINOR 0
#define MAKE_WALLET_RPC_VERSION(major,minor) (((major)<<16)|(minor))
#define WALLET_RPC_VERSION MAKE_WALLET_RPC_VERSION(WALLET_RPC_VERSION_MAJOR, WALLET_RPC_VERSION_MINOR)
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
{
2017-02-19 02:42:10 +00:00
uint32_t account_index;
2014-04-02 16:00:17 +00:00
BEGIN_KV_SERIALIZE_MAP()
2017-02-19 02:42:10 +00:00
KV_SERIALIZE(account_index)
END_KV_SERIALIZE_MAP()
};
struct per_subaddress_info
{
uint32_t address_index;
std::string address;
uint64_t balance;
uint64_t unlocked_balance;
std::string label;
uint64_t num_unspent_outputs;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(address_index)
KV_SERIALIZE(address)
KV_SERIALIZE(balance)
KV_SERIALIZE(unlocked_balance)
KV_SERIALIZE(label)
KV_SERIALIZE(num_unspent_outputs)
2014-04-02 16:00:17 +00:00
END_KV_SERIALIZE_MAP()
};
struct response
{
uint64_t balance;
uint64_t unlocked_balance;
Add N/N multisig tx generation and signing Scheme by luigi1111: Multisig for RingCT on Monero 2 of 2 User A (coordinator): Spendkey b,B Viewkey a,A (shared) User B: Spendkey c,C Viewkey a,A (shared) Public Address: C+B, A Both have their own watch only wallet via C+B, a A will coordinate spending process (though B could easily as well, coordinator is more needed for more participants) A and B watch for incoming outputs B creates "half" key images for discovered output D: I2_D = (Hs(aR)+c) * Hp(D) B also creates 1.5 random keypairs (one scalar and 2 pubkeys; one on base G and one on base Hp(D)) for each output, storing the scalar(k) (linked to D), and sending the pubkeys with I2_D. A also creates "half" key images: I1_D = (Hs(aR)+b) * Hp(D) Then I_D = I1_D + I2_D Having I_D allows A to check spent status of course, but more importantly allows A to actually build a transaction prefix (and thus transaction). A builds the transaction until most of the way through MLSAG_Gen, adding the 2 pubkeys (per input) provided with I2_D to his own generated ones where they are needed (secret row L, R). At this point, A has a mostly completed transaction (but with an invalid/incomplete signature). A sends over the tx and includes r, which allows B (with the recipient's address) to verify the destination and amount (by reconstructing the stealth address and decoding ecdhInfo). B then finishes the signature by computing ss[secret_index][0] = ss[secret_index][0] + k - cc[secret_index]*c (secret indices need to be passed as well). B can then broadcast the tx, or send it back to A for broadcasting. Once B has completed the signing (and verified the tx to be valid), he can add the full I_D to his cache, allowing him to verify spent status as well. NOTE: A and B *must* present key A and B to each other with a valid signature proving they know a and b respectively. Otherwise, trickery like the following becomes possible: A creates viewkey a,A, spendkey b,B, and sends a,A,B to B. B creates a fake key C = zG - B. B sends C back to A. The combined spendkey C+B then equals zG, allowing B to spend funds at any time! The signature fixes this, because B does not know a c corresponding to C (and thus can't produce a signature). 2 of 3 User A (coordinator) Shared viewkey a,A "spendkey" j,J User B "spendkey" k,K User C "spendkey" m,M A collects K and M from B and C B collects J and M from A and C C collects J and K from A and B A computes N = nG, n = Hs(jK) A computes O = oG, o = Hs(jM) B anc C compute P = pG, p = Hs(kM) || Hs(mK) B and C can also compute N and O respectively if they wish to be able to coordinate Address: N+O+P, A The rest follows as above. The coordinator possesses 2 of 3 needed keys; he can get the other needed part of the signature/key images from either of the other two. Alternatively, if secure communication exists between parties: A gives j to B B gives k to C C gives m to A Address: J+K+M, A 3 of 3 Identical to 2 of 2, except the coordinator must collect the key images from both of the others. The transaction must also be passed an additional hop: A -> B -> C (or A -> C -> B), who can then broadcast it or send it back to A. N-1 of N Generally the same as 2 of 3, except participants need to be arranged in a ring to pass their keys around (using either the secure or insecure method). For example (ignoring viewkey so letters line up): [4 of 5] User: spendkey A: a B: b C: c D: d E: e a -> B, b -> C, c -> D, d -> E, e -> A Order of signing does not matter, it just must reach n-1 users. A "remaining keys" list must be passed around with the transaction so the signers know if they should use 1 or both keys. Collecting key image parts becomes a little messy, but basically every wallet sends over both of their parts with a tag for each. Thia way the coordinating wallet can keep track of which images have been added and which wallet they come from. Reasoning: 1. The key images must be added only once (coordinator will get key images for key a from both A and B, he must add only one to get the proper key actual key image) 2. The coordinator must keep track of which helper pubkeys came from which wallet (discussed in 2 of 2 section). The coordinator must choose only one set to use, then include his choice in the "remaining keys" list so the other wallets know which of their keys to use. You can generalize it further to N-2 of N or even M of N, but I'm not sure there's legitimate demand to justify the complexity. It might also be straightforward enough to support with minimal changes from N-1 format. You basically just give each user additional keys for each additional "-1" you desire. N-2 would be 3 keys per user, N-3 4 keys, etc. The process is somewhat cumbersome: To create a N/N multisig wallet: - each participant creates a normal wallet - each participant runs "prepare_multisig", and sends the resulting string to every other participant - each participant runs "make_multisig N A B C D...", with N being the threshold and A B C D... being the strings received from other participants (the threshold must currently equal N) As txes are received, participants' wallets will need to synchronize so that those new outputs may be spent: - each participant runs "export_multisig FILENAME", and sends the FILENAME file to every other participant - each participant runs "import_multisig A B C D...", with A B C D... being the filenames received from other participants Then, a transaction may be initiated: - one of the participants runs "transfer ADDRESS AMOUNT" - this partly signed transaction will be written to the "multisig_monero_tx" file - the initiator sends this file to another participant - that other participant runs "sign_multisig multisig_monero_tx" - the resulting transaction is written to the "multisig_monero_tx" file again - if the threshold was not reached, the file must be sent to another participant, until enough have signed - the last participant to sign runs "submit_multisig multisig_monero_tx" to relay the transaction to the Monero network
2017-06-03 21:34:26 +00:00
bool multisig_import_needed;
2017-02-19 02:42:10 +00:00
std::vector<per_subaddress_info> per_subaddress;
2014-04-02 16:00:17 +00:00
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(balance)
KV_SERIALIZE(unlocked_balance)
Add N/N multisig tx generation and signing Scheme by luigi1111: Multisig for RingCT on Monero 2 of 2 User A (coordinator): Spendkey b,B Viewkey a,A (shared) User B: Spendkey c,C Viewkey a,A (shared) Public Address: C+B, A Both have their own watch only wallet via C+B, a A will coordinate spending process (though B could easily as well, coordinator is more needed for more participants) A and B watch for incoming outputs B creates "half" key images for discovered output D: I2_D = (Hs(aR)+c) * Hp(D) B also creates 1.5 random keypairs (one scalar and 2 pubkeys; one on base G and one on base Hp(D)) for each output, storing the scalar(k) (linked to D), and sending the pubkeys with I2_D. A also creates "half" key images: I1_D = (Hs(aR)+b) * Hp(D) Then I_D = I1_D + I2_D Having I_D allows A to check spent status of course, but more importantly allows A to actually build a transaction prefix (and thus transaction). A builds the transaction until most of the way through MLSAG_Gen, adding the 2 pubkeys (per input) provided with I2_D to his own generated ones where they are needed (secret row L, R). At this point, A has a mostly completed transaction (but with an invalid/incomplete signature). A sends over the tx and includes r, which allows B (with the recipient's address) to verify the destination and amount (by reconstructing the stealth address and decoding ecdhInfo). B then finishes the signature by computing ss[secret_index][0] = ss[secret_index][0] + k - cc[secret_index]*c (secret indices need to be passed as well). B can then broadcast the tx, or send it back to A for broadcasting. Once B has completed the signing (and verified the tx to be valid), he can add the full I_D to his cache, allowing him to verify spent status as well. NOTE: A and B *must* present key A and B to each other with a valid signature proving they know a and b respectively. Otherwise, trickery like the following becomes possible: A creates viewkey a,A, spendkey b,B, and sends a,A,B to B. B creates a fake key C = zG - B. B sends C back to A. The combined spendkey C+B then equals zG, allowing B to spend funds at any time! The signature fixes this, because B does not know a c corresponding to C (and thus can't produce a signature). 2 of 3 User A (coordinator) Shared viewkey a,A "spendkey" j,J User B "spendkey" k,K User C "spendkey" m,M A collects K and M from B and C B collects J and M from A and C C collects J and K from A and B A computes N = nG, n = Hs(jK) A computes O = oG, o = Hs(jM) B anc C compute P = pG, p = Hs(kM) || Hs(mK) B and C can also compute N and O respectively if they wish to be able to coordinate Address: N+O+P, A The rest follows as above. The coordinator possesses 2 of 3 needed keys; he can get the other needed part of the signature/key images from either of the other two. Alternatively, if secure communication exists between parties: A gives j to B B gives k to C C gives m to A Address: J+K+M, A 3 of 3 Identical to 2 of 2, except the coordinator must collect the key images from both of the others. The transaction must also be passed an additional hop: A -> B -> C (or A -> C -> B), who can then broadcast it or send it back to A. N-1 of N Generally the same as 2 of 3, except participants need to be arranged in a ring to pass their keys around (using either the secure or insecure method). For example (ignoring viewkey so letters line up): [4 of 5] User: spendkey A: a B: b C: c D: d E: e a -> B, b -> C, c -> D, d -> E, e -> A Order of signing does not matter, it just must reach n-1 users. A "remaining keys" list must be passed around with the transaction so the signers know if they should use 1 or both keys. Collecting key image parts becomes a little messy, but basically every wallet sends over both of their parts with a tag for each. Thia way the coordinating wallet can keep track of which images have been added and which wallet they come from. Reasoning: 1. The key images must be added only once (coordinator will get key images for key a from both A and B, he must add only one to get the proper key actual key image) 2. The coordinator must keep track of which helper pubkeys came from which wallet (discussed in 2 of 2 section). The coordinator must choose only one set to use, then include his choice in the "remaining keys" list so the other wallets know which of their keys to use. You can generalize it further to N-2 of N or even M of N, but I'm not sure there's legitimate demand to justify the complexity. It might also be straightforward enough to support with minimal changes from N-1 format. You basically just give each user additional keys for each additional "-1" you desire. N-2 would be 3 keys per user, N-3 4 keys, etc. The process is somewhat cumbersome: To create a N/N multisig wallet: - each participant creates a normal wallet - each participant runs "prepare_multisig", and sends the resulting string to every other participant - each participant runs "make_multisig N A B C D...", with N being the threshold and A B C D... being the strings received from other participants (the threshold must currently equal N) As txes are received, participants' wallets will need to synchronize so that those new outputs may be spent: - each participant runs "export_multisig FILENAME", and sends the FILENAME file to every other participant - each participant runs "import_multisig A B C D...", with A B C D... being the filenames received from other participants Then, a transaction may be initiated: - one of the participants runs "transfer ADDRESS AMOUNT" - this partly signed transaction will be written to the "multisig_monero_tx" file - the initiator sends this file to another participant - that other participant runs "sign_multisig multisig_monero_tx" - the resulting transaction is written to the "multisig_monero_tx" file again - if the threshold was not reached, the file must be sent to another participant, until enough have signed - the last participant to sign runs "submit_multisig multisig_monero_tx" to relay the transaction to the Monero network
2017-06-03 21:34:26 +00:00
KV_SERIALIZE(multisig_import_needed)
2017-02-19 02:42:10 +00:00
KV_SERIALIZE(per_subaddress)
2014-04-02 16:00:17 +00:00
END_KV_SERIALIZE_MAP()
};
};
2014-05-24 22:20:46 +00:00
struct COMMAND_RPC_GET_ADDRESS
{
struct request
{
2017-02-19 02:42:10 +00:00
uint32_t account_index;
std::vector<uint32_t> address_index;
2017-02-19 02:42:10 +00:00
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(account_index)
KV_SERIALIZE(address_index)
2017-02-19 02:42:10 +00:00
END_KV_SERIALIZE_MAP()
};
struct address_info
{
std::string address;
std::string label;
uint32_t address_index;
bool used;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(address)
KV_SERIALIZE(label)
KV_SERIALIZE(address_index)
KV_SERIALIZE(used)
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string address; // to remain compatible with older RPC format
std::vector<address_info> addresses;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(address)
KV_SERIALIZE(addresses)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_CREATE_ADDRESS
{
struct request
{
uint32_t account_index;
std::string label;
2014-05-24 22:20:46 +00:00
BEGIN_KV_SERIALIZE_MAP()
2017-02-19 02:42:10 +00:00
KV_SERIALIZE(account_index)
KV_SERIALIZE(label)
2014-05-24 22:20:46 +00:00
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string address;
2017-02-19 02:42:10 +00:00
uint32_t address_index;
2014-05-24 22:20:46 +00:00
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(address)
2017-02-19 02:42:10 +00:00
KV_SERIALIZE(address_index)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_LABEL_ADDRESS
{
struct request
{
cryptonote::subaddress_index index;
std::string label;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(index)
KV_SERIALIZE(label)
END_KV_SERIALIZE_MAP()
};
struct response
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_GET_ACCOUNTS
{
struct request
{
2017-12-15 03:08:36 +00:00
std::string tag; // all accounts if empty, otherwise those accounts with this tag
2017-02-19 02:42:10 +00:00
BEGIN_KV_SERIALIZE_MAP()
2017-12-15 03:08:36 +00:00
KV_SERIALIZE(tag)
2017-02-19 02:42:10 +00:00
END_KV_SERIALIZE_MAP()
};
struct subaddress_account_info
{
uint32_t account_index;
std::string base_address;
uint64_t balance;
uint64_t unlocked_balance;
std::string label;
2017-12-15 03:08:36 +00:00
std::string tag;
2017-02-19 02:42:10 +00:00
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(account_index)
KV_SERIALIZE(base_address)
KV_SERIALIZE(balance)
KV_SERIALIZE(unlocked_balance)
KV_SERIALIZE(label)
2017-12-15 03:08:36 +00:00
KV_SERIALIZE(tag)
2017-02-19 02:42:10 +00:00
END_KV_SERIALIZE_MAP()
};
struct response
{
uint64_t total_balance;
uint64_t total_unlocked_balance;
std::vector<subaddress_account_info> subaddress_accounts;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(total_balance)
KV_SERIALIZE(total_unlocked_balance)
KV_SERIALIZE(subaddress_accounts)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_CREATE_ACCOUNT
{
struct request
{
std::string label;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(label)
END_KV_SERIALIZE_MAP()
};
struct response
{
uint32_t account_index;
std::string address; // the 0-th address for convenience
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(account_index)
KV_SERIALIZE(address)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_LABEL_ACCOUNT
{
struct request
{
uint32_t account_index;
std::string label;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(account_index)
KV_SERIALIZE(label)
END_KV_SERIALIZE_MAP()
};
struct response
{
BEGIN_KV_SERIALIZE_MAP()
2014-05-24 22:20:46 +00:00
END_KV_SERIALIZE_MAP()
};
};
2017-12-15 03:08:36 +00:00
struct COMMAND_RPC_GET_ACCOUNT_TAGS
{
struct request
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
struct account_tag_info
{
std::string tag;
std::string label;
std::vector<uint32_t> accounts;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tag);
KV_SERIALIZE(label);
KV_SERIALIZE(accounts);
END_KV_SERIALIZE_MAP()
};
struct response
{
std::vector<account_tag_info> account_tags;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(account_tags)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_TAG_ACCOUNTS
{
struct request
{
std::string tag;
std::set<uint32_t> accounts;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tag)
KV_SERIALIZE(accounts)
END_KV_SERIALIZE_MAP()
};
struct response
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_UNTAG_ACCOUNTS
{
struct request
{
std::set<uint32_t> accounts;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(accounts)
END_KV_SERIALIZE_MAP()
};
struct response
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_SET_ACCOUNT_TAG_DESCRIPTION
{
struct request
{
std::string tag;
std::string description;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tag)
KV_SERIALIZE(description)
END_KV_SERIALIZE_MAP()
};
2017-02-19 02:42:10 +00:00
struct response
{
BEGIN_KV_SERIALIZE_MAP()
2014-05-24 22:20:46 +00:00
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
};
};
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
{
std::list<transfer_destination> destinations;
2017-02-19 02:42:10 +00:00
uint32_t account_index;
std::set<uint32_t> subaddr_indices;
uint32_t priority;
2014-04-02 16:00:17 +00:00
uint64_t mixin;
uint64_t ring_size;
2014-04-02 16:00:17 +00:00
uint64_t unlock_time;
std::string payment_id;
bool get_tx_key;
bool do_not_relay;
bool get_tx_hex;
bool get_tx_metadata;
2014-04-02 16:00:17 +00:00
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(destinations)
2017-02-19 02:42:10 +00:00
KV_SERIALIZE(account_index)
KV_SERIALIZE(subaddr_indices)
KV_SERIALIZE(priority)
KV_SERIALIZE_OPT(mixin, (uint64_t)0)
KV_SERIALIZE_OPT(ring_size, (uint64_t)0)
2014-04-02 16:00:17 +00:00
KV_SERIALIZE(unlock_time)
KV_SERIALIZE(payment_id)
KV_SERIALIZE(get_tx_key)
KV_SERIALIZE_OPT(do_not_relay, false)
KV_SERIALIZE_OPT(get_tx_hex, false)
KV_SERIALIZE_OPT(get_tx_metadata, false)
2014-04-02 16:00:17 +00:00
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string tx_hash;
std::string tx_key;
2016-07-11 22:14:58 +00:00
std::list<std::string> amount_keys;
uint64_t amount;
2016-11-16 18:56:45 +00:00
uint64_t fee;
std::string tx_blob;
std::string tx_metadata;
2017-11-27 20:09:16 +00:00
std::string multisig_txset;
std::string unsigned_txset;
2014-04-02 16:00:17 +00:00
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tx_hash)
KV_SERIALIZE(tx_key)
2016-07-11 22:14:58 +00:00
KV_SERIALIZE(amount_keys)
KV_SERIALIZE(amount)
2016-11-16 18:56:45 +00:00
KV_SERIALIZE(fee)
KV_SERIALIZE(tx_blob)
KV_SERIALIZE(tx_metadata)
2017-11-27 20:09:16 +00:00
KV_SERIALIZE(multisig_txset)
KV_SERIALIZE(unsigned_txset)
2014-04-02 16:00:17 +00:00
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_TRANSFER_SPLIT
{
struct request
{
std::list<transfer_destination> destinations;
2017-02-19 02:42:10 +00:00
uint32_t account_index;
std::set<uint32_t> subaddr_indices;
uint32_t priority;
uint64_t mixin;
uint64_t ring_size;
uint64_t unlock_time;
std::string payment_id;
bool get_tx_keys;
bool do_not_relay;
bool get_tx_hex;
bool get_tx_metadata;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(destinations)
2017-02-19 02:42:10 +00:00
KV_SERIALIZE(account_index)
KV_SERIALIZE(subaddr_indices)
KV_SERIALIZE(priority)
KV_SERIALIZE_OPT(mixin, (uint64_t)0)
KV_SERIALIZE_OPT(ring_size, (uint64_t)0)
KV_SERIALIZE(unlock_time)
KV_SERIALIZE(payment_id)
KV_SERIALIZE(get_tx_keys)
KV_SERIALIZE_OPT(do_not_relay, false)
KV_SERIALIZE_OPT(get_tx_hex, false)
KV_SERIALIZE_OPT(get_tx_metadata, false)
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()
};
struct response
{
std::list<std::string> tx_hash_list;
std::list<std::string> tx_key_list;
std::list<uint64_t> amount_list;
2016-11-16 18:56:45 +00:00
std::list<uint64_t> fee_list;
std::list<std::string> tx_blob_list;
std::list<std::string> tx_metadata_list;
2017-11-27 20:09:16 +00:00
std::string multisig_txset;
std::string unsigned_txset;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tx_hash_list)
KV_SERIALIZE(tx_key_list)
KV_SERIALIZE(amount_list)
2016-11-16 18:56:45 +00:00
KV_SERIALIZE(fee_list)
KV_SERIALIZE(tx_blob_list)
KV_SERIALIZE(tx_metadata_list)
2017-11-27 20:09:16 +00:00
KV_SERIALIZE(multisig_txset)
KV_SERIALIZE(unsigned_txset)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_SIGN_TRANSFER
{
struct request
{
std::string unsigned_txset;
bool export_raw;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(unsigned_txset)
KV_SERIALIZE_OPT(export_raw, false)
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string signed_txset;
std::list<std::string> tx_hash_list;
std::list<std::string> tx_raw_list;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(signed_txset)
KV_SERIALIZE(tx_hash_list)
KV_SERIALIZE(tx_raw_list)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_SUBMIT_TRANSFER
{
struct request
{
std::string tx_data_hex;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tx_data_hex)
END_KV_SERIALIZE_MAP()
};
struct response
{
std::list<std::string> tx_hash_list;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tx_hash_list)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_SWEEP_DUST
{
struct request
{
bool get_tx_keys;
bool do_not_relay;
bool get_tx_hex;
bool get_tx_metadata;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(get_tx_keys)
KV_SERIALIZE_OPT(do_not_relay, false)
KV_SERIALIZE_OPT(get_tx_hex, false)
KV_SERIALIZE_OPT(get_tx_metadata, false)
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()
};
struct response
{
std::list<std::string> tx_hash_list;
std::list<std::string> tx_key_list;
std::list<uint64_t> amount_list;
2016-11-16 18:56:45 +00:00
std::list<uint64_t> fee_list;
std::list<std::string> tx_blob_list;
std::list<std::string> tx_metadata_list;
std::string multisig_txset;
std::string unsigned_txset;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tx_hash_list)
KV_SERIALIZE(tx_key_list)
KV_SERIALIZE(amount_list)
2016-11-16 18:56:45 +00:00
KV_SERIALIZE(fee_list)
KV_SERIALIZE(tx_blob_list)
KV_SERIALIZE(tx_metadata_list)
2017-11-27 20:09:16 +00:00
KV_SERIALIZE(multisig_txset)
KV_SERIALIZE(unsigned_txset)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_SWEEP_ALL
{
struct request
{
std::string address;
2017-02-19 02:42:10 +00:00
uint32_t account_index;
std::set<uint32_t> subaddr_indices;
uint32_t priority;
uint64_t mixin;
uint64_t ring_size;
uint64_t unlock_time;
std::string payment_id;
bool get_tx_keys;
uint64_t below_amount;
bool do_not_relay;
bool get_tx_hex;
bool get_tx_metadata;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(address)
2017-02-19 02:42:10 +00:00
KV_SERIALIZE(account_index)
KV_SERIALIZE(subaddr_indices)
KV_SERIALIZE(priority)
KV_SERIALIZE_OPT(mixin, (uint64_t)0)
KV_SERIALIZE_OPT(ring_size, (uint64_t)0)
KV_SERIALIZE(unlock_time)
KV_SERIALIZE(payment_id)
KV_SERIALIZE(get_tx_keys)
KV_SERIALIZE(below_amount)
KV_SERIALIZE_OPT(do_not_relay, false)
KV_SERIALIZE_OPT(get_tx_hex, false)
KV_SERIALIZE_OPT(get_tx_metadata, false)
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()
};
struct response
{
std::list<std::string> tx_hash_list;
std::list<std::string> tx_key_list;
std::list<uint64_t> amount_list;
2016-11-16 18:56:45 +00:00
std::list<uint64_t> fee_list;
std::list<std::string> tx_blob_list;
std::list<std::string> tx_metadata_list;
std::string multisig_txset;
std::string unsigned_txset;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tx_hash_list)
KV_SERIALIZE(tx_key_list)
KV_SERIALIZE(amount_list)
2016-11-16 18:56:45 +00:00
KV_SERIALIZE(fee_list)
KV_SERIALIZE(tx_blob_list)
KV_SERIALIZE(tx_metadata_list)
2017-11-27 20:09:16 +00:00
KV_SERIALIZE(multisig_txset)
KV_SERIALIZE(unsigned_txset)
END_KV_SERIALIZE_MAP()
};
};
2017-10-11 01:32:06 +00:00
struct COMMAND_RPC_SWEEP_SINGLE
{
struct request
{
std::string address;
uint32_t priority;
uint64_t mixin;
uint64_t ring_size;
2017-10-11 01:32:06 +00:00
uint64_t unlock_time;
std::string payment_id;
bool get_tx_key;
std::string key_image;
bool do_not_relay;
bool get_tx_hex;
bool get_tx_metadata;
2017-10-11 01:32:06 +00:00
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(address)
KV_SERIALIZE(priority)
KV_SERIALIZE_OPT(mixin, (uint64_t)0)
KV_SERIALIZE_OPT(ring_size, (uint64_t)0)
2017-10-11 01:32:06 +00:00
KV_SERIALIZE(unlock_time)
KV_SERIALIZE(payment_id)
KV_SERIALIZE(get_tx_key)
KV_SERIALIZE(key_image)
KV_SERIALIZE_OPT(do_not_relay, false)
KV_SERIALIZE_OPT(get_tx_hex, false)
KV_SERIALIZE_OPT(get_tx_metadata, false)
2017-10-11 01:32:06 +00:00
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string tx_hash;
std::string tx_key;
uint64_t amount;
2017-10-11 01:32:06 +00:00
uint64_t fee;
std::string tx_blob;
std::string tx_metadata;
2017-11-27 20:09:16 +00:00
std::string multisig_txset;
std::string unsigned_txset;
2017-10-11 01:32:06 +00:00
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tx_hash)
KV_SERIALIZE(tx_key)
KV_SERIALIZE(amount)
2017-10-11 01:32:06 +00:00
KV_SERIALIZE(fee)
KV_SERIALIZE(tx_blob)
KV_SERIALIZE(tx_metadata)
2017-11-27 20:09:16 +00:00
KV_SERIALIZE(multisig_txset)
KV_SERIALIZE(unsigned_txset)
2017-10-11 01:32:06 +00:00
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_RELAY_TX
{
struct request
{
std::string hex;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(hex)
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string tx_hash;
std::string tx_key;
uint64_t fee;
std::string tx_blob;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tx_hash)
KV_SERIALIZE(tx_key)
KV_SERIALIZE(fee)
KV_SERIALIZE(tx_blob)
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;
2017-02-19 02:42:10 +00:00
cryptonote::subaddress_index subaddr_index;
std::string address;
2014-05-03 16:19:43 +00:00
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)
2017-02-19 02:42:10 +00:00
KV_SERIALIZE(subaddr_index)
KV_SERIALIZE(address)
2014-05-03 16:19:43 +00:00
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()
};
};
struct transfer_details
{
uint64_t amount;
bool spent;
uint64_t global_index;
std::string tx_hash;
uint64_t tx_size;
2017-02-19 02:42:10 +00:00
uint32_t subaddr_index;
2017-10-11 01:32:06 +00:00
std::string key_image;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(amount)
KV_SERIALIZE(spent)
KV_SERIALIZE(global_index)
KV_SERIALIZE(tx_hash)
KV_SERIALIZE(tx_size)
2017-02-19 02:42:10 +00:00
KV_SERIALIZE(subaddr_index)
2017-10-11 01:32:06 +00:00
KV_SERIALIZE(key_image)
END_KV_SERIALIZE_MAP()
};
struct COMMAND_RPC_INCOMING_TRANSFERS
{
struct request
{
std::string transfer_type;
2017-02-19 02:42:10 +00:00
uint32_t account_index;
std::set<uint32_t> subaddr_indices;
2017-10-11 01:32:06 +00:00
bool verbose;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(transfer_type)
2017-02-19 02:42:10 +00:00
KV_SERIALIZE(account_index)
KV_SERIALIZE(subaddr_indices)
2017-10-11 01:32:06 +00:00
KV_SERIALIZE(verbose)
END_KV_SERIALIZE_MAP()
};
struct response
{
std::list<transfer_details> transfers;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(transfers)
END_KV_SERIALIZE_MAP()
};
};
//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()
};
};
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;
std::string payment_id;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(integrated_address)
KV_SERIALIZE(payment_id)
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;
2017-02-19 02:42:10 +00:00
bool is_subaddress;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(standard_address)
KV_SERIALIZE(payment_id)
2017-02-19 02:42:10 +00:00
KV_SERIALIZE(is_subaddress)
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()
};
};
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()
};
};
struct COMMAND_RPC_SET_ATTRIBUTE
{
struct request
{
std::string key;
std::string value;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(key)
KV_SERIALIZE(value)
END_KV_SERIALIZE_MAP()
};
struct response
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_GET_ATTRIBUTE
{
struct request
{
std::string key;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(key)
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string value;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(value)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_GET_TX_KEY
{
struct request
{
std::string txid;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(txid)
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string tx_key;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tx_key)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_CHECK_TX_KEY
{
struct request
{
std::string txid;
std::string tx_key;
std::string address;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(txid)
KV_SERIALIZE(tx_key)
KV_SERIALIZE(address)
END_KV_SERIALIZE_MAP()
};
struct response
{
uint64_t received;
bool in_pool;
uint64_t confirmations;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(received)
KV_SERIALIZE(in_pool)
KV_SERIALIZE(confirmations)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_GET_TX_PROOF
{
struct request
{
std::string txid;
std::string address;
std::string message;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(txid)
KV_SERIALIZE(address)
KV_SERIALIZE(message)
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string signature;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(signature)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_CHECK_TX_PROOF
{
struct request
{
std::string txid;
std::string address;
std::string message;
std::string signature;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(txid)
KV_SERIALIZE(address)
KV_SERIALIZE(message)
KV_SERIALIZE(signature)
END_KV_SERIALIZE_MAP()
};
struct response
{
bool good;
uint64_t received;
bool in_pool;
uint64_t confirmations;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(good)
KV_SERIALIZE(received)
KV_SERIALIZE(in_pool)
KV_SERIALIZE(confirmations)
END_KV_SERIALIZE_MAP()
};
};
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;
uint64_t unlock_time;
2017-02-19 02:42:10 +00:00
cryptonote::subaddress_index subaddr_index;
2017-12-27 00:35:48 +00:00
std::string address;
bool double_spend_seen;
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);
KV_SERIALIZE(unlock_time)
2017-02-19 02:42:10 +00:00
KV_SERIALIZE(subaddr_index);
2017-12-27 00:35:48 +00:00
KV_SERIALIZE(address);
KV_SERIALIZE(double_spend_seen)
END_KV_SERIALIZE_MAP()
};
2017-08-28 15:34:17 +00:00
struct COMMAND_RPC_GET_SPEND_PROOF
{
struct request
{
std::string txid;
std::string message;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(txid)
KV_SERIALIZE(message)
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string signature;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(signature)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_CHECK_SPEND_PROOF
{
struct request
{
std::string txid;
std::string message;
std::string signature;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(txid)
KV_SERIALIZE(message)
KV_SERIALIZE(signature)
END_KV_SERIALIZE_MAP()
};
struct response
{
bool good;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(good)
END_KV_SERIALIZE_MAP()
2017-12-28 13:50:10 +00:00
};
};
struct COMMAND_RPC_GET_RESERVE_PROOF
{
struct request
{
bool all;
uint32_t account_index; // ignored when `all` is true
uint64_t amount; // ignored when `all` is true
std::string message;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(all)
KV_SERIALIZE(account_index)
KV_SERIALIZE(amount)
KV_SERIALIZE(message)
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string signature;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(signature)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_CHECK_RESERVE_PROOF
{
struct request
{
std::string address;
std::string message;
std::string signature;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(address)
KV_SERIALIZE(message)
KV_SERIALIZE(signature)
END_KV_SERIALIZE_MAP()
};
struct response
{
bool good;
uint64_t total;
uint64_t spent;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(good)
KV_SERIALIZE(total)
KV_SERIALIZE(spent)
END_KV_SERIALIZE_MAP()
2017-08-28 15:34:17 +00:00
};
};
struct COMMAND_RPC_GET_TRANSFERS
{
struct request
{
bool in;
bool out;
bool pending;
bool failed;
bool pool;
bool filter_by_height;
uint64_t min_height;
uint64_t max_height;
2017-02-19 02:42:10 +00:00
uint32_t account_index;
std::set<uint32_t> subaddr_indices;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(in);
KV_SERIALIZE(out);
KV_SERIALIZE(pending);
KV_SERIALIZE(failed);
KV_SERIALIZE(pool);
KV_SERIALIZE(filter_by_height);
KV_SERIALIZE(min_height);
KV_SERIALIZE_OPT(max_height, (uint64_t)CRYPTONOTE_MAX_BLOCK_NUMBER);
2017-02-19 02:42:10 +00:00
KV_SERIALIZE(account_index);
KV_SERIALIZE(subaddr_indices);
END_KV_SERIALIZE_MAP()
};
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
{
std::string txid;
uint32_t account_index;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(txid);
KV_SERIALIZE_OPT(account_index, (uint32_t)0)
END_KV_SERIALIZE_MAP()
};
struct response
{
transfer_entry transfer;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(transfer);
END_KV_SERIALIZE_MAP()
};
};
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()
};
};
struct COMMAND_RPC_EXPORT_OUTPUTS
{
struct request
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string outputs_data_hex;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(outputs_data_hex);
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_IMPORT_OUTPUTS
{
struct request
{
std::string outputs_data_hex;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(outputs_data_hex);
END_KV_SERIALIZE_MAP()
};
struct response
{
uint64_t num_imported;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(num_imported);
END_KV_SERIALIZE_MAP()
};
};
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()
};
};
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()
};
};
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()
};
};
struct COMMAND_RPC_RESCAN_SPENT
{
struct request
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
struct response
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
};
2017-03-19 11:31:38 +00:00
struct COMMAND_RPC_START_MINING
{
struct request
{
uint64_t threads_count;
bool do_background_mining;
bool ignore_battery;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(threads_count)
KV_SERIALIZE(do_background_mining)
KV_SERIALIZE(ignore_battery)
END_KV_SERIALIZE_MAP()
};
struct response
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_STOP_MINING
{
struct request
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
struct response
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_GET_LANGUAGES
{
struct request
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
struct response
{
std::vector<std::string> languages;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(languages)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_CREATE_WALLET
{
struct request
{
std::string filename;
std::string password;
std::string language;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(filename)
KV_SERIALIZE(password)
KV_SERIALIZE(language)
END_KV_SERIALIZE_MAP()
};
struct response
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_OPEN_WALLET
{
struct request
{
std::string filename;
std::string password;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(filename)
KV_SERIALIZE(password)
END_KV_SERIALIZE_MAP()
};
struct response
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
};
2017-11-27 20:09:04 +00:00
struct COMMAND_RPC_IS_MULTISIG
{
struct request
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
struct response
{
bool multisig;
bool ready;
2017-11-27 20:09:04 +00:00
uint32_t threshold;
uint32_t total;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(multisig)
KV_SERIALIZE(ready)
2017-11-27 20:09:04 +00:00
KV_SERIALIZE(threshold)
KV_SERIALIZE(total)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_PREPARE_MULTISIG
{
struct request
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string multisig_info;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(multisig_info)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_MAKE_MULTISIG
{
struct request
{
std::vector<std::string> multisig_info;
uint32_t threshold;
std::string password;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(multisig_info)
KV_SERIALIZE(threshold)
KV_SERIALIZE(password)
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string address;
2017-08-13 14:29:31 +00:00
std::string multisig_info;
2017-11-27 20:09:04 +00:00
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(address)
2017-08-13 14:29:31 +00:00
KV_SERIALIZE(multisig_info)
2017-11-27 20:09:04 +00:00
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_EXPORT_MULTISIG
{
struct request
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string info;
2017-11-27 20:09:04 +00:00
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(info)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_IMPORT_MULTISIG
{
struct request
{
std::vector<std::string> info;
2017-11-27 20:09:04 +00:00
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(info)
END_KV_SERIALIZE_MAP()
};
struct response
{
uint64_t n_outputs;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(n_outputs)
END_KV_SERIALIZE_MAP()
};
};
2017-08-13 14:29:31 +00:00
struct COMMAND_RPC_FINALIZE_MULTISIG
{
struct request
{
std::string password;
std::vector<std::string> multisig_info;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(password)
KV_SERIALIZE(multisig_info)
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string address;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(address)
END_KV_SERIALIZE_MAP()
};
};
2017-11-27 20:09:16 +00:00
struct COMMAND_RPC_SIGN_MULTISIG
{
struct request
{
std::string tx_data_hex;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tx_data_hex)
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string tx_data_hex;
std::list<std::string> tx_hash_list;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tx_data_hex)
KV_SERIALIZE(tx_hash_list)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_SUBMIT_MULTISIG
{
struct request
{
std::string tx_data_hex;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tx_data_hex)
END_KV_SERIALIZE_MAP()
};
struct response
{
std::list<std::string> tx_hash_list;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tx_hash_list)
END_KV_SERIALIZE_MAP()
};
};
struct COMMAND_RPC_GET_VERSION
{
struct request
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
struct response
{
uint32_t version;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(version)
END_KV_SERIALIZE_MAP()
};
};
2014-04-02 16:00:17 +00:00
}
}