2016-01-18 15:33:29 +00:00
// Copyright (c) 2011-2016 The Cryptonote developers
2015-09-18 11:55:31 +00:00
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
2014-03-03 22:07:58 +00:00
# pragma once
2015-07-15 12:23:00 +00:00
2015-07-30 15:22:07 +00:00
# include "CryptoNoteProtocol/CryptoNoteProtocolDefinitions.h"
# include "CryptoNoteCore/CryptoNoteBasic.h"
# include "CryptoNoteCore/Difficulty.h"
2014-03-03 22:07:58 +00:00
# include "crypto/hash.h"
2015-07-30 15:22:07 +00:00
# include "Serialization/SerializationOverloads.h"
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
namespace CryptoNote {
//-----------------------------------------------
# define CORE_RPC_STATUS_OK "OK"
# define CORE_RPC_STATUS_BUSY "BUSY"
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
struct EMPTY_STRUCT {
void serialize ( ISerializer & s ) { }
} ;
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
struct STATUS_STRUCT {
std : : string status ;
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
void serialize ( ISerializer & s ) {
KV_MEMBER ( status )
}
} ;
2014-03-20 11:46:11 +00:00
2015-07-15 12:23:00 +00:00
struct COMMAND_RPC_GET_HEIGHT {
typedef EMPTY_STRUCT request ;
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
struct response {
uint64_t height ;
2014-08-13 10:51:37 +00:00
std : : string status ;
2015-07-15 12:23:00 +00:00
void serialize ( ISerializer & s ) {
KV_MEMBER ( height )
KV_MEMBER ( status )
}
2014-08-13 10:51:37 +00:00
} ;
2015-07-15 12:23:00 +00:00
} ;
2014-08-13 10:51:37 +00:00
2015-07-15 12:23:00 +00:00
struct COMMAND_RPC_GET_BLOCKS_FAST {
2014-08-13 10:51:37 +00:00
2015-07-15 12:23:00 +00:00
struct request {
2015-07-30 15:22:07 +00:00
std : : vector < 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 */
2015-07-15 12:23:00 +00:00
void serialize ( ISerializer & s ) {
serializeAsBinary ( block_ids , " block_ids " , s ) ;
}
2014-03-03 22:07:58 +00:00
} ;
2015-07-15 12:23:00 +00:00
struct response {
2015-07-30 15:22:07 +00:00
std : : vector < block_complete_entry > blocks ;
2015-07-15 12:23:00 +00:00
uint64_t start_height ;
uint64_t current_height ;
std : : string status ;
void serialize ( ISerializer & s ) {
KV_MEMBER ( blocks )
KV_MEMBER ( start_height )
KV_MEMBER ( current_height )
KV_MEMBER ( status )
}
2014-03-03 22:07:58 +00:00
} ;
2015-07-15 12:23:00 +00:00
} ;
//-----------------------------------------------
struct COMMAND_RPC_GET_TRANSACTIONS {
struct request {
2015-07-30 15:22:07 +00:00
std : : vector < std : : string > txs_hashes ;
2015-07-15 12:23:00 +00:00
void serialize ( ISerializer & s ) {
KV_MEMBER ( txs_hashes )
}
2014-03-03 22:07:58 +00:00
} ;
2015-07-15 12:23:00 +00:00
struct response {
2015-07-30 15:22:07 +00:00
std : : vector < std : : string > txs_as_hex ; //transactions blobs as hex
std : : vector < std : : string > missed_tx ; //not found transactions
2015-07-15 12:23:00 +00:00
std : : string status ;
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
void serialize ( ISerializer & s ) {
KV_MEMBER ( txs_as_hex )
KV_MEMBER ( missed_tx )
KV_MEMBER ( status )
}
} ;
} ;
//-----------------------------------------------
struct COMMAND_RPC_GET_POOL_CHANGES {
struct request {
2015-07-30 15:22:07 +00:00
Crypto : : Hash tailBlockId ;
std : : vector < Crypto : : Hash > knownTxsIds ;
2015-07-15 12:23:00 +00:00
void serialize ( ISerializer & s ) {
KV_MEMBER ( tailBlockId )
serializeAsBinary ( knownTxsIds , " knownTxsIds " , s ) ;
}
} ;
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
struct response {
bool isTailBlockActual ;
2015-07-30 15:22:07 +00:00
std : : vector < BinaryArray > addedTxs ; // Added transactions blobs
std : : vector < Crypto : : Hash > deletedTxsIds ; // IDs of not found transactions
2015-07-15 12:23:00 +00:00
std : : string status ;
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
void serialize ( ISerializer & s ) {
KV_MEMBER ( isTailBlockActual )
KV_MEMBER ( addedTxs )
serializeAsBinary ( deletedTxsIds , " deletedTxsIds " , s ) ;
KV_MEMBER ( status )
}
} ;
} ;
2015-07-30 15:22:07 +00:00
struct COMMAND_RPC_GET_POOL_CHANGES_LITE {
struct request {
Crypto : : Hash tailBlockId ;
std : : vector < Crypto : : Hash > knownTxsIds ;
void serialize ( ISerializer & s ) {
KV_MEMBER ( tailBlockId )
serializeAsBinary ( knownTxsIds , " knownTxsIds " , s ) ;
}
} ;
struct response {
bool isTailBlockActual ;
std : : vector < TransactionPrefixInfo > addedTxs ; // Added transactions blobs
std : : vector < Crypto : : Hash > deletedTxsIds ; // IDs of not found transactions
std : : string status ;
void serialize ( ISerializer & s ) {
KV_MEMBER ( isTailBlockActual )
KV_MEMBER ( addedTxs )
serializeAsBinary ( deletedTxsIds , " deletedTxsIds " , s ) ;
KV_MEMBER ( status )
}
} ;
} ;
2015-07-15 12:23:00 +00:00
//-----------------------------------------------
struct COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES {
struct request {
2015-07-30 15:22:07 +00:00
Crypto : : Hash txid ;
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
void serialize ( ISerializer & s ) {
KV_MEMBER ( txid )
}
2014-03-03 22:07:58 +00:00
} ;
2015-07-15 12:23:00 +00:00
struct response {
std : : vector < uint64_t > o_indexes ;
std : : string status ;
2015-04-06 16:13:07 +00:00
2015-07-15 12:23:00 +00:00
void serialize ( ISerializer & s ) {
KV_MEMBER ( o_indexes )
KV_MEMBER ( status )
}
} ;
} ;
//-----------------------------------------------
struct COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS_request {
std : : vector < uint64_t > amounts ;
uint64_t outs_count ;
void serialize ( ISerializer & s ) {
KV_MEMBER ( amounts )
KV_MEMBER ( outs_count )
}
} ;
# pragma pack(push, 1)
struct COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS_out_entry {
uint64_t global_amount_index ;
2015-07-30 15:22:07 +00:00
Crypto : : PublicKey out_key ;
2015-07-15 12:23:00 +00:00
} ;
# pragma pack(pop)
2015-04-06 16:13:07 +00:00
2015-07-15 12:23:00 +00:00
struct COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS_outs_for_amount {
uint64_t amount ;
2015-07-30 15:22:07 +00:00
std : : vector < COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS_out_entry > outs ;
2015-07-15 12:23:00 +00:00
void serialize ( ISerializer & s ) {
KV_MEMBER ( amount )
serializeAsBinary ( outs , " outs " , s ) ;
}
} ;
struct COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS_response {
std : : vector < COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS_outs_for_amount > outs ;
std : : string status ;
void serialize ( ISerializer & s ) {
KV_MEMBER ( outs ) ;
KV_MEMBER ( status )
}
} ;
struct COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS {
typedef COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS_request request ;
typedef COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS_response response ;
typedef COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS_out_entry out_entry ;
typedef COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS_outs_for_amount outs_for_amount ;
} ;
//-----------------------------------------------
struct COMMAND_RPC_SEND_RAW_TX {
struct request {
std : : string tx_as_hex ;
request ( ) { }
explicit request ( const Transaction & ) ;
void serialize ( ISerializer & s ) {
KV_MEMBER ( tx_as_hex )
}
} ;
2015-04-06 16:13:07 +00:00
2015-07-15 12:23:00 +00:00
struct response {
std : : string status ;
2015-04-06 16:13:07 +00:00
2015-07-15 12:23:00 +00:00
void serialize ( ISerializer & s ) {
KV_MEMBER ( status )
}
} ;
} ;
//-----------------------------------------------
struct COMMAND_RPC_START_MINING {
struct request {
std : : string miner_address ;
uint64_t threads_count ;
void serialize ( ISerializer & s ) {
KV_MEMBER ( miner_address )
KV_MEMBER ( threads_count )
}
2015-04-06 16:13:07 +00:00
} ;
2015-07-15 12:23:00 +00:00
struct response {
std : : string status ;
void serialize ( ISerializer & s ) {
KV_MEMBER ( status )
}
} ;
} ;
//-----------------------------------------------
struct COMMAND_RPC_GET_INFO {
typedef EMPTY_STRUCT request ;
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
struct response {
std : : string status ;
uint64_t height ;
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 ;
2015-12-09 13:19:03 +00:00
uint32_t last_known_block_index ;
2015-07-15 12:23:00 +00:00
void serialize ( ISerializer & s ) {
KV_MEMBER ( status )
KV_MEMBER ( height )
KV_MEMBER ( difficulty )
KV_MEMBER ( tx_count )
KV_MEMBER ( tx_pool_size )
KV_MEMBER ( alt_blocks_count )
KV_MEMBER ( outgoing_connections_count )
KV_MEMBER ( incoming_connections_count )
KV_MEMBER ( white_peerlist_size )
KV_MEMBER ( grey_peerlist_size )
2015-12-09 13:19:03 +00:00
KV_MEMBER ( last_known_block_index )
2015-07-15 12:23:00 +00:00
}
} ;
} ;
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
//-----------------------------------------------
struct COMMAND_RPC_STOP_MINING {
typedef EMPTY_STRUCT request ;
typedef STATUS_STRUCT response ;
} ;
2014-03-20 11:46:11 +00:00
2015-07-15 12:23:00 +00:00
//-----------------------------------------------
struct COMMAND_RPC_STOP_DAEMON {
typedef EMPTY_STRUCT request ;
typedef STATUS_STRUCT response ;
} ;
2014-03-20 11:46:11 +00:00
2015-07-15 12:23:00 +00:00
//
struct COMMAND_RPC_GETBLOCKCOUNT {
2015-07-30 15:22:07 +00:00
typedef std : : vector < std : : string > request ;
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
struct response {
uint64_t count ;
std : : string status ;
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
void serialize ( ISerializer & s ) {
KV_MEMBER ( count )
KV_MEMBER ( status )
}
} ;
} ;
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 ;
void serialize ( ISerializer & s ) {
KV_MEMBER ( reserve_size )
KV_MEMBER ( wallet_address )
}
2014-03-03 22:07:58 +00:00
} ;
2015-07-15 12:23:00 +00:00
struct response {
uint64_t difficulty ;
uint32_t height ;
uint64_t reserved_offset ;
2015-07-30 15:22:07 +00:00
std : : string blocktemplate_blob ;
2015-07-15 12:23:00 +00:00
std : : string status ;
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
void serialize ( ISerializer & s ) {
KV_MEMBER ( difficulty )
KV_MEMBER ( height )
KV_MEMBER ( reserved_offset )
KV_MEMBER ( blocktemplate_blob )
KV_MEMBER ( status )
}
2014-03-03 22:07:58 +00:00
} ;
2015-07-15 12:23:00 +00:00
} ;
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
struct COMMAND_RPC_GET_CURRENCY_ID {
typedef EMPTY_STRUCT request ;
2014-08-13 10:51:37 +00:00
2015-07-15 12:23:00 +00:00
struct response {
std : : string currency_id_blob ;
void serialize ( ISerializer & s ) {
KV_MEMBER ( currency_id_blob )
}
2014-03-03 22:07:58 +00:00
} ;
2015-07-15 12:23:00 +00:00
} ;
struct COMMAND_RPC_SUBMITBLOCK {
typedef std : : vector < std : : string > request ;
typedef STATUS_STRUCT response ;
} ;
2015-07-30 15:22:07 +00:00
struct block_header_response {
2015-07-15 12:23:00 +00:00
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 ;
void serialize ( ISerializer & s ) {
KV_MEMBER ( major_version )
KV_MEMBER ( minor_version )
KV_MEMBER ( timestamp )
KV_MEMBER ( prev_hash )
KV_MEMBER ( nonce )
KV_MEMBER ( orphan_status )
KV_MEMBER ( height )
KV_MEMBER ( depth )
KV_MEMBER ( hash )
KV_MEMBER ( difficulty )
KV_MEMBER ( reward )
}
} ;
struct BLOCK_HEADER_RESPONSE {
std : : string status ;
2015-07-30 15:22:07 +00:00
block_header_response block_header ;
2015-07-15 12:23:00 +00:00
void serialize ( ISerializer & s ) {
KV_MEMBER ( block_header )
KV_MEMBER ( status )
}
} ;
struct COMMAND_RPC_GET_LAST_BLOCK_HEADER {
typedef EMPTY_STRUCT request ;
typedef BLOCK_HEADER_RESPONSE response ;
} ;
struct COMMAND_RPC_GET_BLOCK_HEADER_BY_HASH {
struct request {
std : : string hash ;
void serialize ( ISerializer & s ) {
KV_MEMBER ( hash )
}
2014-04-09 12:14:35 +00:00
} ;
2015-07-15 12:23:00 +00:00
typedef BLOCK_HEADER_RESPONSE response ;
} ;
struct COMMAND_RPC_GET_BLOCK_HEADER_BY_HEIGHT {
struct request {
uint64_t height ;
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
void serialize ( ISerializer & s ) {
KV_MEMBER ( height )
}
2014-04-09 12:14:35 +00:00
} ;
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
typedef BLOCK_HEADER_RESPONSE response ;
} ;
2014-04-09 12:14:35 +00:00
2015-07-15 12:23:00 +00:00
struct COMMAND_RPC_QUERY_BLOCKS {
struct request {
2015-07-30 15:22:07 +00:00
std : : vector < 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 */
2015-07-15 12:23:00 +00:00
uint64_t timestamp ;
void serialize ( ISerializer & s ) {
serializeAsBinary ( block_ids , " block_ids " , s ) ;
KV_MEMBER ( timestamp )
}
2014-04-09 12:14:35 +00:00
} ;
2014-03-03 22:07:58 +00:00
2015-07-15 12:23:00 +00:00
struct response {
std : : string status ;
uint64_t start_height ;
uint64_t current_height ;
uint64_t full_offset ;
2015-07-30 15:22:07 +00:00
std : : vector < BlockFullInfo > items ;
2015-07-15 12:23:00 +00:00
void serialize ( ISerializer & s ) {
KV_MEMBER ( status )
KV_MEMBER ( start_height )
KV_MEMBER ( current_height )
KV_MEMBER ( full_offset )
KV_MEMBER ( items )
}
2014-08-13 10:51:37 +00:00
} ;
2015-07-15 12:23:00 +00:00
} ;
2015-07-30 15:22:07 +00:00
struct COMMAND_RPC_QUERY_BLOCKS_LITE {
struct request {
std : : vector < Crypto : : Hash > blockIds ;
uint64_t timestamp ;
void serialize ( ISerializer & s ) {
serializeAsBinary ( blockIds , " block_ids " , s ) ;
KV_MEMBER ( timestamp )
}
} ;
struct response {
std : : string status ;
uint64_t startHeight ;
uint64_t currentHeight ;
uint64_t fullOffset ;
std : : vector < BlockShortInfo > items ;
void serialize ( ISerializer & s ) {
KV_MEMBER ( status )
KV_MEMBER ( startHeight )
KV_MEMBER ( currentHeight )
KV_MEMBER ( fullOffset )
KV_MEMBER ( items )
}
} ;
} ;
2014-03-03 22:07:58 +00:00
}