mirror of
https://git.wownero.com/wownero/wownero.git
synced 2024-08-15 01:03:23 +00:00
The RPC calls the daemon executable uses to talk to the running daemon instance have mostly been added back in. Rate limiting has not been added in upstream, but is on its way in a separate effort, so those calls are still NOPed out.
708 lines
15 KiB
C++
708 lines
15 KiB
C++
// Copyright (c) 2014-2015, The Monero Project
|
|
//
|
|
// 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
|
|
|
|
#pragma once
|
|
#include "cryptonote_protocol/cryptonote_protocol_defs.h"
|
|
#include "cryptonote_core/cryptonote_basic.h"
|
|
#include "cryptonote_core/difficulty.h"
|
|
#include "crypto/hash.h"
|
|
|
|
namespace cryptonote
|
|
{
|
|
//-----------------------------------------------
|
|
#define CORE_RPC_STATUS_OK "OK"
|
|
#define CORE_RPC_STATUS_BUSY "BUSY"
|
|
#define CORE_RPC_STATUS_NOT_MINING "NOT MINING"
|
|
|
|
struct COMMAND_RPC_GET_HEIGHT
|
|
{
|
|
struct request
|
|
{
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
END_KV_SERIALIZE_MAP()
|
|
};
|
|
|
|
struct response
|
|
{
|
|
uint64_t height;
|
|
std::string status;
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
KV_SERIALIZE(height)
|
|
KV_SERIALIZE(status)
|
|
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 */
|
|
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<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;
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
KV_SERIALIZE(txs_hashes)
|
|
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
|
|
std::string status;
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
KV_SERIALIZE(txs_as_hex)
|
|
KV_SERIALIZE(missed_tx)
|
|
KV_SERIALIZE(status)
|
|
END_KV_SERIALIZE_MAP()
|
|
};
|
|
};
|
|
|
|
//-----------------------------------------------
|
|
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
|
|
{
|
|
std::vector<uint64_t> amounts;
|
|
uint64_t outs_count;
|
|
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;
|
|
|
|
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;
|
|
uint64_t target_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;
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
KV_SERIALIZE(status)
|
|
KV_SERIALIZE(height)
|
|
KV_SERIALIZE(target_height)
|
|
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()
|
|
};
|
|
};
|
|
|
|
//-----------------------------------------------
|
|
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()
|
|
};
|
|
};
|
|
|
|
//-----------------------------------------------
|
|
struct COMMAND_RPC_SAVE_BC
|
|
{
|
|
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_GETBLOCKCOUNT
|
|
{
|
|
typedef std::list<std::string> request;
|
|
|
|
struct response
|
|
{
|
|
uint64_t count;
|
|
std::string status;
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
KV_SERIALIZE(count)
|
|
KV_SERIALIZE(status)
|
|
END_KV_SERIALIZE_MAP()
|
|
};
|
|
|
|
};
|
|
|
|
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;
|
|
std::string prev_hash;
|
|
blobdata blocktemplate_blob;
|
|
std::string status;
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
KV_SERIALIZE(difficulty)
|
|
KV_SERIALIZE(height)
|
|
KV_SERIALIZE(reserved_offset)
|
|
KV_SERIALIZE(prev_hash)
|
|
KV_SERIALIZE(blocktemplate_blob)
|
|
KV_SERIALIZE(status)
|
|
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()
|
|
};
|
|
};
|
|
|
|
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()
|
|
};
|
|
|
|
struct COMMAND_RPC_GET_LAST_BLOCK_HEADER
|
|
{
|
|
struct request
|
|
{
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
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()
|
|
};
|
|
|
|
};
|
|
|
|
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()
|
|
};
|
|
|
|
};
|
|
|
|
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()
|
|
};
|
|
|
|
};
|
|
|
|
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()
|
|
};
|
|
|
|
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;
|
|
|
|
BEGIN_KV_SERIALIZE_MAP()
|
|
KV_SERIALIZE(status)
|
|
KV_SERIALIZE(transactions)
|
|
END_KV_SERIALIZE_MAP()
|
|
};
|
|
};
|
|
|
|
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()
|
|
KV_SERIALIZE(status)
|
|
KV_SERIALIZE(connections)
|
|
END_KV_SERIALIZE_MAP()
|
|
};
|
|
|
|
};
|
|
|
|
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()
|
|
};
|
|
};
|
|
}
|
|
|