2015-01-02 16:52:46 +00:00
// Copyright (c) 2014-2015, 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-03-03 22:07:58 +00:00
# pragma once
# include "cryptonote_protocol/cryptonote_protocol_defs.h"
# include "cryptonote_core/cryptonote_basic.h"
2014-04-09 12:14:35 +00:00
# include "cryptonote_core/difficulty.h"
2014-03-03 22:07:58 +00:00
# include "crypto/hash.h"
namespace cryptonote
{
//-----------------------------------------------
# define CORE_RPC_STATUS_OK "OK"
2014-03-20 11:46:11 +00:00
# define CORE_RPC_STATUS_BUSY "BUSY"
2015-02-05 09:11:20 +00:00
# define CORE_RPC_STATUS_NOT_MINING "NOT MINING"
2014-03-03 22:07:58 +00:00
struct COMMAND_RPC_GET_HEIGHT
{
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
uint64_t height ;
2014-03-20 11:46:11 +00:00
std : : string status ;
2014-03-03 22:07:58 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( height )
2014-03-20 11:46:11 +00:00
KV_SERIALIZE ( status )
2014-03-03 22:07:58 +00:00
END_KV_SERIALIZE_MAP ( )
} ;
} ;
struct COMMAND_RPC_GET_BLOCKS_FAST
{
struct request
{
std : : list < crypto : : hash > block_ids ; //*first 10 blocks id goes sequential, next goes in pow(2,n) offset, like 2, 4, 8, 16, 32, 64 and so on, and the last one is always genesis block */
2014-08-01 08:17:50 +00:00
uint64_t start_height ;
2014-03-03 22:07:58 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE_CONTAINER_POD_AS_BLOB ( block_ids )
2014-08-01 08:17:50 +00:00
KV_SERIALIZE ( start_height )
2014-03-03 22:07:58 +00:00
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : list < block_complete_entry > blocks ;
uint64_t start_height ;
uint64_t current_height ;
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( blocks )
KV_SERIALIZE ( start_height )
KV_SERIALIZE ( current_height )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
//-----------------------------------------------
struct COMMAND_RPC_GET_TRANSACTIONS
{
struct request
{
std : : list < std : : string > txs_hashes ;
2015-10-13 21:11:52 +00:00
bool decode_as_json ;
2014-03-03 22:07:58 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( txs_hashes )
2015-10-13 21:11:52 +00:00
KV_SERIALIZE ( decode_as_json )
2014-03-03 22:07:58 +00:00
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : list < std : : string > txs_as_hex ; //transactions blobs as hex
std : : list < std : : string > missed_tx ; //not found transactions
2015-10-13 21:11:52 +00:00
std : : list < std : : string > txs_as_json ; //transactions decoded as json
2014-03-03 22:07:58 +00:00
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( txs_as_hex )
KV_SERIALIZE ( missed_tx )
2015-10-13 21:11:52 +00:00
KV_SERIALIZE ( txs_as_json )
2014-03-03 22:07:58 +00:00
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2015-08-11 09:49:15 +00:00
//-----------------------------------------------
struct COMMAND_RPC_IS_KEY_IMAGE_SPENT
{
struct request
{
std : : vector < std : : string > key_images ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( key_images )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
2015-08-13 15:33:28 +00:00
std : : vector < int > spent_status ;
2015-08-11 09:49:15 +00:00
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( spent_status )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2014-03-03 22:07:58 +00:00
//-----------------------------------------------
struct COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES
{
struct request
{
crypto : : hash txid ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE_VAL_POD_AS_BLOB ( txid )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : vector < uint64_t > o_indexes ;
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( o_indexes )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
//-----------------------------------------------
struct COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS
{
struct request
{
2014-07-01 16:10:19 +00:00
std : : vector < uint64_t > amounts ;
uint64_t outs_count ;
2014-03-03 22:07:58 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( amounts )
KV_SERIALIZE ( outs_count )
END_KV_SERIALIZE_MAP ( )
} ;
# pragma pack (push, 1)
struct out_entry
{
uint64_t global_amount_index ;
crypto : : public_key out_key ;
} ;
# pragma pack(pop)
struct outs_for_amount
{
uint64_t amount ;
std : : list < out_entry > outs ;
2014-03-20 11:46:11 +00:00
2014-03-03 22:07:58 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( amount )
KV_SERIALIZE_CONTAINER_POD_AS_BLOB ( outs )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : vector < outs_for_amount > outs ;
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( outs )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
//-----------------------------------------------
struct COMMAND_RPC_SEND_RAW_TX
{
struct request
{
std : : string tx_as_hex ;
request ( ) { }
explicit request ( const transaction & ) ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( tx_as_hex )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
//-----------------------------------------------
struct COMMAND_RPC_START_MINING
{
struct request
{
std : : string miner_address ;
uint64_t threads_count ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( miner_address )
KV_SERIALIZE ( threads_count )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
//-----------------------------------------------
struct COMMAND_RPC_GET_INFO
{
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
uint64_t height ;
2014-06-04 20:50:13 +00:00
uint64_t target_height ;
2014-03-03 22:07:58 +00:00
uint64_t difficulty ;
uint64_t tx_count ;
uint64_t tx_pool_size ;
uint64_t alt_blocks_count ;
uint64_t outgoing_connections_count ;
uint64_t incoming_connections_count ;
uint64_t white_peerlist_size ;
uint64_t grey_peerlist_size ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
KV_SERIALIZE ( height )
2014-06-04 20:50:13 +00:00
KV_SERIALIZE ( target_height )
2014-03-03 22:07:58 +00:00
KV_SERIALIZE ( difficulty )
KV_SERIALIZE ( tx_count )
KV_SERIALIZE ( tx_pool_size )
KV_SERIALIZE ( alt_blocks_count )
KV_SERIALIZE ( outgoing_connections_count )
KV_SERIALIZE ( incoming_connections_count )
KV_SERIALIZE ( white_peerlist_size )
KV_SERIALIZE ( grey_peerlist_size )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
//-----------------------------------------------
struct COMMAND_RPC_STOP_MINING
{
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2014-05-25 19:36:12 +00:00
//-----------------------------------------------
struct COMMAND_RPC_MINING_STATUS
{
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
bool active ;
uint64_t speed ;
uint32_t threads_count ;
std : : string address ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
KV_SERIALIZE ( active )
KV_SERIALIZE ( speed )
KV_SERIALIZE ( threads_count )
KV_SERIALIZE ( address )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2014-05-15 22:21:43 +00:00
//-----------------------------------------------
struct COMMAND_RPC_SAVE_BC
{
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
2014-03-03 22:07:58 +00:00
2014-05-15 22:21:43 +00:00
struct response
{
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2014-03-03 22:07:58 +00:00
//
struct COMMAND_RPC_GETBLOCKCOUNT
{
typedef std : : list < std : : string > request ;
2014-03-20 11:46:11 +00:00
struct response
{
uint64_t count ;
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( count )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
2014-03-03 22:07:58 +00:00
} ;
struct COMMAND_RPC_GETBLOCKHASH
{
typedef std : : vector < uint64_t > request ;
typedef std : : string response ;
} ;
struct COMMAND_RPC_GETBLOCKTEMPLATE
{
struct request
{
uint64_t reserve_size ; //max 255 bytes
std : : string wallet_address ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( reserve_size )
KV_SERIALIZE ( wallet_address )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
uint64_t difficulty ;
uint64_t height ;
uint64_t reserved_offset ;
2015-01-06 16:37:10 +00:00
std : : string prev_hash ;
2014-03-03 22:07:58 +00:00
blobdata blocktemplate_blob ;
2014-03-20 11:46:11 +00:00
std : : string status ;
2014-03-03 22:07:58 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( difficulty )
KV_SERIALIZE ( height )
KV_SERIALIZE ( reserved_offset )
2015-01-06 16:37:10 +00:00
KV_SERIALIZE ( prev_hash )
2014-03-03 22:07:58 +00:00
KV_SERIALIZE ( blocktemplate_blob )
2014-03-20 11:46:11 +00:00
KV_SERIALIZE ( status )
2014-03-03 22:07:58 +00:00
END_KV_SERIALIZE_MAP ( )
} ;
} ;
struct COMMAND_RPC_SUBMITBLOCK
{
typedef std : : vector < std : : string > request ;
struct response
{
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2014-04-09 12:14:35 +00:00
struct block_header_responce
{
uint8_t major_version ;
uint8_t minor_version ;
uint64_t timestamp ;
std : : string prev_hash ;
uint32_t nonce ;
bool orphan_status ;
uint64_t height ;
uint64_t depth ;
std : : string hash ;
difficulty_type difficulty ;
uint64_t reward ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( major_version )
KV_SERIALIZE ( minor_version )
KV_SERIALIZE ( timestamp )
KV_SERIALIZE ( prev_hash )
KV_SERIALIZE ( nonce )
KV_SERIALIZE ( orphan_status )
KV_SERIALIZE ( height )
KV_SERIALIZE ( depth )
KV_SERIALIZE ( hash )
KV_SERIALIZE ( difficulty )
KV_SERIALIZE ( reward )
END_KV_SERIALIZE_MAP ( )
} ;
2015-02-05 09:11:20 +00:00
2014-04-09 12:14:35 +00:00
struct COMMAND_RPC_GET_LAST_BLOCK_HEADER
{
2014-07-01 16:11:06 +00:00
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
2014-04-09 12:14:35 +00:00
struct response
{
std : : string status ;
block_header_responce block_header ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( block_header )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
struct COMMAND_RPC_GET_BLOCK_HEADER_BY_HASH
{
struct request
{
std : : string hash ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( hash )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
block_header_responce block_header ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( block_header )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
2014-03-03 22:07:58 +00:00
2014-04-09 12:14:35 +00:00
} ;
2014-03-03 22:07:58 +00:00
2014-04-09 12:14:35 +00:00
struct COMMAND_RPC_GET_BLOCK_HEADER_BY_HEIGHT
{
struct request
{
uint64_t height ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( height )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
block_header_responce block_header ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( block_header )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2014-03-03 22:07:58 +00:00
2015-10-13 20:37:35 +00:00
struct COMMAND_RPC_GET_BLOCK
{
struct request
{
std : : string hash ;
uint64_t height ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( hash )
KV_SERIALIZE ( height )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
block_header_responce block_header ;
std : : vector < std : : string > tx_hashes ;
std : : string blob ;
std : : string json ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( block_header )
KV_SERIALIZE ( tx_hashes )
KV_SERIALIZE ( status )
KV_SERIALIZE ( blob )
KV_SERIALIZE ( json )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2015-02-05 09:11:20 +00:00
struct peer {
uint64_t id ;
uint32_t ip ;
uint16_t port ;
uint64_t last_seen ;
peer ( ) = default ;
peer ( uint64_t id , uint32_t ip , uint16_t port , uint64_t last_seen )
: id ( id ) , ip ( ip ) , port ( port ) , last_seen ( last_seen )
{ }
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( id )
KV_SERIALIZE ( ip )
KV_SERIALIZE ( port )
KV_SERIALIZE ( last_seen )
END_KV_SERIALIZE_MAP ( )
} ;
struct COMMAND_RPC_GET_PEER_LIST
{
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
std : : vector < peer > white_list ;
std : : vector < peer > gray_list ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
KV_SERIALIZE ( white_list )
KV_SERIALIZE ( gray_list )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
struct COMMAND_RPC_SET_LOG_HASH_RATE
{
struct request
{
bool visible ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( visible )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
struct COMMAND_RPC_SET_LOG_LEVEL
{
struct request
{
int8_t level ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( level )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
struct tx_info
{
std : : string id_hash ;
std : : string tx_json ; // TODO - expose this data directly
uint64_t blob_size ;
uint64_t fee ;
std : : string max_used_block_id_hash ;
uint64_t max_used_block_height ;
bool kept_by_block ;
uint64_t last_failed_height ;
std : : string last_failed_id_hash ;
uint64_t receive_time ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( id_hash )
KV_SERIALIZE ( tx_json )
KV_SERIALIZE ( blob_size )
KV_SERIALIZE ( fee )
KV_SERIALIZE ( max_used_block_id_hash )
KV_SERIALIZE ( max_used_block_height )
KV_SERIALIZE ( kept_by_block )
KV_SERIALIZE ( last_failed_height )
KV_SERIALIZE ( last_failed_id_hash )
KV_SERIALIZE ( receive_time )
END_KV_SERIALIZE_MAP ( )
} ;
2015-04-23 12:13:07 +00:00
struct spent_key_image_info
{
std : : string id_hash ;
std : : vector < std : : string > txs_hashes ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( id_hash )
KV_SERIALIZE ( txs_hashes )
END_KV_SERIALIZE_MAP ( )
} ;
2015-02-05 09:11:20 +00:00
struct COMMAND_RPC_GET_TRANSACTION_POOL
{
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
std : : vector < tx_info > transactions ;
2015-04-23 12:13:07 +00:00
std : : vector < spent_key_image_info > spent_key_images ;
2015-02-05 09:11:20 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
KV_SERIALIZE ( transactions )
2015-04-23 12:13:07 +00:00
KV_SERIALIZE ( spent_key_images )
2015-02-05 09:11:20 +00:00
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2014-07-18 23:33:03 +00:00
struct COMMAND_RPC_GET_CONNECTIONS
{
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
std : : list < connection_info > connections ;
BEGIN_KV_SERIALIZE_MAP ( )
2014-07-23 00:54:45 +00:00
KV_SERIALIZE ( status )
2014-07-18 23:33:03 +00:00
KV_SERIALIZE ( connections )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2015-02-05 09:11:20 +00:00
struct COMMAND_RPC_GET_BLOCK_HEADERS_RANGE
{
struct request
{
uint64_t start_height ;
uint64_t end_height ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( start_height )
KV_SERIALIZE ( end_height )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
std : : vector < block_header_responce > headers ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
KV_SERIALIZE ( headers )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
struct COMMAND_RPC_STOP_DAEMON
{
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2015-04-01 17:00:45 +00:00
struct COMMAND_RPC_FAST_EXIT
{
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
struct COMMAND_RPC_OUT_PEERS
{
struct request
{
uint64_t out_peers ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( out_peers )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
struct COMMAND_RPC_START_SAVE_GRAPH
{
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
struct COMMAND_RPC_STOP_SAVE_GRAPH
{
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2015-09-19 15:34:29 +00:00
struct COMMAND_RPC_HARD_FORK_INFO
{
struct request
{
uint8_t version ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( version )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
uint8_t version ;
bool enabled ;
uint32_t window ;
uint32_t votes ;
uint32_t threshold ;
uint8_t voting ;
uint32_t state ;
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( version )
KV_SERIALIZE ( enabled )
KV_SERIALIZE ( window )
KV_SERIALIZE ( votes )
KV_SERIALIZE ( threshold )
KV_SERIALIZE ( voting )
KV_SERIALIZE ( state )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2014-03-03 22:07:58 +00:00
}