2015-12-31 06:39:56 +00:00
// Copyright (c) 2014-2016, The Monero Project
2016-10-10 20:41:24 +00:00
//
2014-07-23 13:03:52 +00:00
// All rights reserved.
2016-10-10 20:41:24 +00:00
//
2014-07-23 13:03:52 +00:00
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
2016-10-10 20:41:24 +00:00
//
2014-07-23 13:03:52 +00:00
// 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
2016-10-10 20:41:24 +00:00
//
2014-07-23 13:03:52 +00:00
// 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.
2016-10-10 20:41:24 +00:00
//
2014-07-23 13:03:52 +00:00
// 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.
2016-10-10 20:41:24 +00:00
//
2014-07-23 13:03:52 +00:00
// 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.
2016-10-10 20:41:24 +00:00
//
2014-07-23 13:03:52 +00:00
// 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
2016-11-26 12:53:33 +00:00
// When making *any* change here, bump minor
// If the change is incompatible, then bump major and set minor to 0
// This ensures CORE_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 daemon without having to know in
// advance which version they will stop working with
// Don't go over 32767 for any of these
# define CORE_RPC_VERSION_MAJOR 1
2017-01-08 11:14:11 +00:00
# define CORE_RPC_VERSION_MINOR 5
2017-01-15 07:54:13 +00:00
# define MAKE_CORE_RPC_VERSION(major,minor) (((major)<<16)|(minor))
# define CORE_RPC_VERSION MAKE_CORE_RPC_VERSION(CORE_RPC_VERSION_MAJOR, CORE_RPC_VERSION_MINOR)
2016-07-10 15:49:40 +00:00
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 ( )
} ;
2016-07-13 18:26:11 +00:00
struct tx_output_indices
{
std : : vector < uint64_t > indices ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( indices )
END_KV_SERIALIZE_MAP ( )
} ;
struct block_output_indices
{
std : : vector < tx_output_indices > indices ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( indices )
END_KV_SERIALIZE_MAP ( )
} ;
2014-03-03 22:07:58 +00:00
struct response
{
std : : list < block_complete_entry > blocks ;
uint64_t start_height ;
uint64_t current_height ;
std : : string status ;
2016-07-13 18:26:11 +00:00
std : : vector < block_output_indices > output_indices ;
2014-03-03 22:07:58 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( blocks )
KV_SERIALIZE ( start_height )
KV_SERIALIZE ( current_height )
KV_SERIALIZE ( status )
2016-07-13 18:26:11 +00:00
KV_SERIALIZE ( output_indices )
2014-03-03 22:07:58 +00:00
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2016-04-13 22:45:02 +00:00
struct COMMAND_RPC_GET_HASHES_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 */
uint64_t start_height ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE_CONTAINER_POD_AS_BLOB ( block_ids )
KV_SERIALIZE ( start_height )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : list < crypto : : hash > m_block_ids ;
uint64_t start_height ;
uint64_t current_height ;
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE_CONTAINER_POD_AS_BLOB ( m_block_ids )
KV_SERIALIZE ( start_height )
KV_SERIALIZE ( current_height )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2014-03-03 22:07:58 +00:00
//-----------------------------------------------
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 ( )
} ;
2016-04-03 11:51:28 +00:00
struct entry
{
std : : string tx_hash ;
std : : string as_hex ;
std : : string as_json ;
bool in_pool ;
uint64_t block_height ;
2016-11-20 14:12:19 +00:00
std : : vector < uint64_t > output_indices ;
2016-04-03 11:51:28 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( tx_hash )
KV_SERIALIZE ( as_hex )
KV_SERIALIZE ( as_json )
KV_SERIALIZE ( in_pool )
KV_SERIALIZE ( block_height )
2016-11-20 14:12:19 +00:00
KV_SERIALIZE ( output_indices )
2016-04-03 11:51:28 +00:00
END_KV_SERIALIZE_MAP ( )
} ;
2014-03-03 22:07:58 +00:00
struct response
{
2016-04-03 11:51:28 +00:00
// older compatibility stuff
std : : list < std : : string > txs_as_hex ; //transactions blobs as hex (old compat)
std : : list < std : : string > txs_as_json ; //transactions decoded as json (old compat)
// in both old and new
2014-03-03 22:07:58 +00:00
std : : list < std : : string > missed_tx ; //not found transactions
2016-04-03 11:51:28 +00:00
// new style
std : : vector < entry > txs ;
2014-03-03 22:07:58 +00:00
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( txs_as_hex )
2015-10-13 21:11:52 +00:00
KV_SERIALIZE ( txs_as_json )
2016-04-03 11:51:28 +00:00
KV_SERIALIZE ( txs )
KV_SERIALIZE ( missed_tx )
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
{
2016-01-05 21:57:43 +00:00
enum STATUS {
UNSPENT = 0 ,
SPENT_IN_BLOCKCHAIN = 1 ,
SPENT_IN_POOL = 2 ,
} ;
2015-08-11 09:49:15 +00:00
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 ( )
} ;
} ;
//-----------------------------------------------
2016-11-22 20:00:40 +00:00
struct get_outputs_out
2016-08-02 20:48:09 +00:00
{
2016-11-22 20:00:40 +00:00
uint64_t amount ;
uint64_t index ;
2016-08-02 20:48:09 +00:00
2016-11-22 20:00:40 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( amount )
KV_SERIALIZE ( index )
END_KV_SERIALIZE_MAP ( )
} ;
2016-08-02 20:48:09 +00:00
2016-11-22 20:00:40 +00:00
struct COMMAND_RPC_GET_OUTPUTS_BIN
{
2016-08-02 20:48:09 +00:00
struct request
{
2016-11-22 20:00:40 +00:00
std : : vector < get_outputs_out > outputs ;
2016-08-02 20:48:09 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( outputs )
END_KV_SERIALIZE_MAP ( )
} ;
struct outkey
{
crypto : : public_key key ;
2016-08-21 08:56:32 +00:00
rct : : key mask ;
2016-08-02 20:48:09 +00:00
bool unlocked ;
2016-12-23 12:04:54 +00:00
uint64_t height ;
crypto : : hash txid ;
2016-08-02 20:48:09 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE_VAL_POD_AS_BLOB ( key )
2016-08-21 08:56:32 +00:00
KV_SERIALIZE_VAL_POD_AS_BLOB ( mask )
2016-08-02 20:48:09 +00:00
KV_SERIALIZE ( unlocked )
2016-12-23 12:04:54 +00:00
KV_SERIALIZE ( height )
KV_SERIALIZE_VAL_POD_AS_BLOB ( txid )
2016-08-02 20:48:09 +00:00
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : vector < outkey > outs ;
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( outs )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2016-11-22 20:00:40 +00:00
//-----------------------------------------------
struct COMMAND_RPC_GET_OUTPUTS
{
struct request
{
std : : vector < get_outputs_out > outputs ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( outputs )
END_KV_SERIALIZE_MAP ( )
} ;
struct outkey
{
std : : string key ;
std : : string mask ;
bool unlocked ;
2016-12-23 12:04:54 +00:00
uint64_t height ;
std : : string txid ;
2016-11-22 20:00:40 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( key )
KV_SERIALIZE ( mask )
KV_SERIALIZE ( unlocked )
2016-12-23 12:04:54 +00:00
KV_SERIALIZE ( height )
KV_SERIALIZE ( txid )
2016-11-22 20:00:40 +00:00
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : vector < outkey > outs ;
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( outs )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2016-06-05 09:46:18 +00:00
struct COMMAND_RPC_GET_RANDOM_RCT_OUTPUTS
{
struct request
{
uint64_t outs_count ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( outs_count )
END_KV_SERIALIZE_MAP ( )
} ;
# pragma pack (push, 1)
struct out_entry
{
2016-06-15 22:37:13 +00:00
uint64_t amount ;
2016-06-05 09:46:18 +00:00
uint64_t global_amount_index ;
crypto : : public_key out_key ;
rct : : key commitment ;
} ;
# pragma pack(pop)
struct response
{
std : : list < out_entry > outs ;
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE_CONTAINER_POD_AS_BLOB ( outs )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2016-08-02 20:48:09 +00:00
//-----------------------------------------------
2014-03-03 22:07:58 +00:00
struct COMMAND_RPC_SEND_RAW_TX
{
struct request
{
std : : string tx_as_hex ;
2016-04-05 18:13:24 +00:00
bool do_not_relay ;
2014-03-03 22:07:58 +00:00
request ( ) { }
explicit request ( const transaction & ) ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( tx_as_hex )
2016-04-05 18:13:24 +00:00
KV_SERIALIZE ( do_not_relay )
2014-03-03 22:07:58 +00:00
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
2016-03-27 11:35:36 +00:00
std : : string reason ;
bool not_relayed ;
bool low_mixin ;
bool double_spend ;
bool invalid_input ;
bool invalid_output ;
bool too_big ;
bool overspend ;
bool fee_too_low ;
2016-07-02 09:02:12 +00:00
bool not_rct ;
2014-03-03 22:07:58 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
2016-03-27 11:35:36 +00:00
KV_SERIALIZE ( reason )
KV_SERIALIZE ( not_relayed )
KV_SERIALIZE ( low_mixin )
KV_SERIALIZE ( double_spend )
KV_SERIALIZE ( invalid_input )
KV_SERIALIZE ( invalid_output )
KV_SERIALIZE ( too_big )
KV_SERIALIZE ( overspend )
KV_SERIALIZE ( fee_too_low )
2016-07-02 09:02:12 +00:00
KV_SERIALIZE ( not_rct )
2014-03-03 22:07:58 +00:00
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 ;
2015-11-26 00:25:13 +00:00
uint64_t target ;
2014-03-03 22:07:58 +00:00
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-10-28 18:08:14 +00:00
bool testnet ;
2015-12-18 19:56:17 +00:00
std : : string top_block_hash ;
2016-10-15 14:00:21 +00:00
uint64_t cumulative_difficulty ;
2017-01-06 19:26:47 +00:00
uint64_t block_size_limit ;
2017-01-08 23:50:29 +00:00
uint64_t start_time ;
2014-03-03 22:07:58 +00:00
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 )
2016-01-11 22:52:01 +00:00
KV_SERIALIZE ( target )
2014-03-03 22:07:58 +00:00
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 )
2015-10-28 18:08:14 +00:00
KV_SERIALIZE ( testnet )
2015-12-18 19:56:17 +00:00
KV_SERIALIZE ( top_block_hash )
2016-10-15 14:00:21 +00:00
KV_SERIALIZE ( cumulative_difficulty )
2017-01-06 19:26:47 +00:00
KV_SERIALIZE ( block_size_limit )
2017-01-08 23:50:29 +00:00
KV_SERIALIZE ( start_time )
2014-03-03 22:07:58 +00:00
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2016-10-10 20:41:24 +00:00
2014-03-03 22:07:58 +00:00
//-----------------------------------------------
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 ( )
} ;
} ;
2016-10-10 20:41:24 +00:00
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 ;
2016-03-30 01:50:51 +00:00
blobdata blockhashing_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 )
2016-03-30 01:50:51 +00:00
KV_SERIALIZE ( blockhashing_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 ;
2016-10-10 20:41:24 +00:00
2014-03-03 22:07:58 +00:00
struct response
{
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2016-10-10 20:41:24 +00:00
2016-09-29 13:38:12 +00:00
struct block_header_response
2014-04-09 12:14:35 +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 ;
2017-01-06 19:35:59 +00:00
uint64_t block_size ;
2017-01-08 11:14:11 +00:00
uint64_t num_txes ;
2016-10-10 20:41:24 +00:00
2014-04-09 12:14:35 +00:00
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 )
2017-01-06 19:35:59 +00:00
KV_SERIALIZE ( block_size )
2017-01-08 11:14:11 +00:00
KV_SERIALIZE ( num_txes )
2014-04-09 12:14:35 +00:00
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 ;
2016-09-29 13:38:12 +00:00
block_header_response block_header ;
2016-10-10 20:41:24 +00:00
2014-04-09 12:14:35 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( block_header )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2016-10-10 20:41:24 +00:00
2014-04-09 12:14:35 +00:00
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 ;
2016-09-29 13:38:12 +00:00
block_header_response block_header ;
2016-10-10 20:41:24 +00:00
2014-04-09 12:14:35 +00:00
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 ;
2016-09-29 13:38:12 +00:00
block_header_response block_header ;
2016-10-10 20:41:24 +00:00
2014-04-09 12:14:35 +00:00
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 ;
2016-09-29 13:38:12 +00:00
block_header_response block_header ;
2015-10-13 20:37:35 +00:00
std : : vector < std : : string > tx_hashes ;
std : : string blob ;
std : : string json ;
2016-10-10 20:41:24 +00:00
2015-10-13 20:37:35 +00:00
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 ;
2016-10-22 19:47:31 +00:00
bool relayed ;
uint64_t last_relayed_time ;
2017-01-14 13:01:21 +00:00
bool do_not_relay ;
2015-02-05 09:11:20 +00:00
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 )
2016-10-22 19:47:31 +00:00
KV_SERIALIZE ( relayed )
2016-12-24 18:06:16 +00:00
KV_SERIALIZE ( last_relayed_time )
2017-01-14 13:01:21 +00:00
KV_SERIALIZE ( do_not_relay )
2015-02-05 09:11:20 +00:00
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 ;
2016-10-10 20:41:24 +00:00
2014-07-18 23:33:03 +00:00
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 ;
2016-09-29 13:38:12 +00:00
std : : vector < block_header_response > headers ;
2015-02-05 09:11:20 +00:00
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 ( )
} ;
} ;
2016-10-10 20:41:24 +00:00
2015-04-01 17:00:45 +00:00
struct COMMAND_RPC_FAST_EXIT
{
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
2016-10-10 20:41:24 +00:00
2015-04-01 17:00:45 +00:00
struct response
{
std : : string status ;
2016-10-10 20:41:24 +00:00
2015-04-01 17:00:45 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2016-10-10 20:41:24 +00:00
2015-04-01 17:00:45 +00:00
struct COMMAND_RPC_OUT_PEERS
{
struct request
{
uint64_t out_peers ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( out_peers )
END_KV_SERIALIZE_MAP ( )
} ;
2016-10-10 20:41:24 +00:00
2015-04-01 17:00:45 +00:00
struct response
{
std : : string status ;
2016-10-10 20:41:24 +00:00
2015-04-01 17:00:45 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2016-10-10 20:41:24 +00:00
2015-04-01 17:00:45 +00:00
struct COMMAND_RPC_START_SAVE_GRAPH
{
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
2016-10-10 20:41:24 +00:00
2015-04-01 17:00:45 +00:00
struct response
{
std : : string status ;
2016-10-10 20:41:24 +00:00
2015-04-01 17:00:45 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2016-10-10 20:41:24 +00:00
2015-04-01 17:00:45 +00:00
struct COMMAND_RPC_STOP_SAVE_GRAPH
{
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
2016-10-10 20:41:24 +00:00
2015-04-01 17:00:45 +00:00
struct response
{
std : : string status ;
2016-10-10 20:41:24 +00:00
2015-04-01 17:00:45 +00:00
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 ;
2015-12-19 14:52:30 +00:00
uint64_t earliest_height ;
2015-09-19 15:34:29 +00:00
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 )
2015-12-19 14:52:30 +00:00
KV_SERIALIZE ( earliest_height )
2015-09-19 15:34:29 +00:00
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2015-11-26 00:04:22 +00:00
struct COMMAND_RPC_GETBANS
{
struct ban
{
uint32_t ip ;
uint32_t seconds ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( ip )
KV_SERIALIZE ( seconds )
END_KV_SERIALIZE_MAP ( )
} ;
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
std : : vector < ban > bans ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
KV_SERIALIZE ( bans )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
struct COMMAND_RPC_SETBANS
{
struct ban
{
uint32_t ip ;
bool ban ;
uint32_t seconds ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( ip )
KV_SERIALIZE ( ban )
KV_SERIALIZE ( seconds )
END_KV_SERIALIZE_MAP ( )
} ;
struct request
{
std : : vector < ban > bans ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( bans )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2016-01-30 13:28:26 +00:00
struct COMMAND_RPC_FLUSH_TRANSACTION_POOL
{
struct request
{
std : : list < std : : string > txids ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( txids )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2016-03-26 14:30:23 +00:00
struct COMMAND_RPC_GET_OUTPUT_HISTOGRAM
{
struct request
{
std : : vector < uint64_t > amounts ;
uint64_t min_count ;
uint64_t max_count ;
2016-08-01 21:16:00 +00:00
bool unlocked ;
2016-09-17 14:45:51 +00:00
uint64_t recent_cutoff ;
2016-03-26 14:30:23 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( amounts ) ;
KV_SERIALIZE ( min_count ) ;
KV_SERIALIZE ( max_count ) ;
2016-08-01 21:16:00 +00:00
KV_SERIALIZE ( unlocked ) ;
2016-09-17 14:45:51 +00:00
KV_SERIALIZE ( recent_cutoff ) ;
2016-03-26 14:30:23 +00:00
END_KV_SERIALIZE_MAP ( )
} ;
struct entry
{
uint64_t amount ;
2016-09-17 14:45:51 +00:00
uint64_t total_instances ;
uint64_t unlocked_instances ;
uint64_t recent_instances ;
2016-03-26 14:30:23 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( amount ) ;
2016-09-17 14:45:51 +00:00
KV_SERIALIZE ( total_instances ) ;
KV_SERIALIZE ( unlocked_instances ) ;
KV_SERIALIZE ( recent_instances ) ;
2016-03-26 14:30:23 +00:00
END_KV_SERIALIZE_MAP ( )
2016-09-17 14:45:51 +00:00
entry ( uint64_t amount , uint64_t total_instances , uint64_t unlocked_instances , uint64_t recent_instances ) :
amount ( amount ) , total_instances ( total_instances ) , unlocked_instances ( unlocked_instances ) , recent_instances ( recent_instances ) { }
2016-03-26 14:30:23 +00:00
entry ( ) { }
} ;
struct response
{
std : : string status ;
std : : vector < entry > histogram ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
KV_SERIALIZE ( histogram )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2016-07-10 15:49:40 +00:00
struct COMMAND_RPC_GET_VERSION
{
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
uint32_t version ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
KV_SERIALIZE ( version )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2014-03-03 22:07:58 +00:00
2016-10-10 19:45:51 +00:00
struct COMMAND_RPC_GET_COINBASE_TX_SUM
{
struct request
{
2016-10-10 21:19:36 +00:00
uint64_t height ;
uint64_t count ;
2016-10-10 19:45:51 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
2016-10-10 21:19:36 +00:00
KV_SERIALIZE ( height ) ;
KV_SERIALIZE ( count ) ;
2016-10-10 19:45:51 +00:00
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
2016-10-10 23:55:18 +00:00
uint64_t emission_amount ;
uint64_t fee_amount ;
2016-10-10 19:45:51 +00:00
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
2016-10-10 23:55:18 +00:00
KV_SERIALIZE ( emission_amount )
KV_SERIALIZE ( fee_amount )
2016-10-10 19:45:51 +00:00
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2016-10-28 20:19:40 +00:00
struct COMMAND_RPC_GET_PER_KB_FEE_ESTIMATE
{
struct request
{
uint64_t grace_blocks ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( grace_blocks )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
uint64_t fee ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
KV_SERIALIZE ( fee )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2016-12-17 11:25:15 +00:00
struct COMMAND_RPC_GET_ALTERNATE_CHAINS
{
struct request
{
BEGIN_KV_SERIALIZE_MAP ( )
END_KV_SERIALIZE_MAP ( )
} ;
struct chain_info
{
std : : string block_hash ;
uint64_t height ;
uint64_t length ;
uint64_t difficulty ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( block_hash )
KV_SERIALIZE ( height )
KV_SERIALIZE ( length )
KV_SERIALIZE ( difficulty )
END_KV_SERIALIZE_MAP ( )
} ;
struct response
{
std : : string status ;
std : : list < chain_info > chains ;
BEGIN_KV_SERIALIZE_MAP ( )
KV_SERIALIZE ( status )
KV_SERIALIZE ( chains )
END_KV_SERIALIZE_MAP ( )
} ;
} ;
2016-10-10 19:45:51 +00:00
}