Replace the JavaScript mobile app with a native Swift iOS wallet
This commit is contained in:
@@ -0,0 +1,60 @@
|
||||
/**
|
||||
* Copyright (c) woodser
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*
|
||||
* Parts of this file are originally copyright (c) 2014-2019, The Monero Project
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification, are
|
||||
* permitted provided that the following conditions are met:
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
* 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
|
||||
*/
|
||||
|
||||
#include "monero_daemon.h"
|
||||
|
||||
/**
|
||||
* Public library intereface.
|
||||
*/
|
||||
namespace monero {
|
||||
|
||||
}
|
||||
@@ -0,0 +1,805 @@
|
||||
/**
|
||||
* Copyright (c) woodser
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*
|
||||
* Parts of this file are originally copyright (c) 2014-2019, The Monero Project
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification, are
|
||||
* permitted provided that the following conditions are met:
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
* 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 "common/monero_rpc_connection.h"
|
||||
#include "monero_daemon_model.h"
|
||||
|
||||
/**
|
||||
* Public library interface.
|
||||
*/
|
||||
namespace monero {
|
||||
|
||||
/**
|
||||
* Receives notifications as a daemon is updated.
|
||||
*/
|
||||
class monero_daemon_listener {
|
||||
public:
|
||||
std::shared_ptr<monero_block_header> m_last_header;
|
||||
|
||||
/**
|
||||
* Called when a new block is added to the chain.
|
||||
*
|
||||
* @param header is the header of the block added to the chain
|
||||
*/
|
||||
virtual void on_block_header(const std::shared_ptr<monero_block_header>& header) {
|
||||
m_last_header = header;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Monero daemon interface.
|
||||
*/
|
||||
class monero_daemon {
|
||||
public:
|
||||
|
||||
/**
|
||||
* Virtual destructor.
|
||||
*/
|
||||
virtual ~monero_daemon() {}
|
||||
|
||||
/**
|
||||
* Register a listener receive daemon notifications.
|
||||
*
|
||||
* @param listener is the listener to receive daemon notifications
|
||||
*/
|
||||
virtual void add_listener(monero_daemon_listener &listener) {
|
||||
throw std::runtime_error("monero_daemon::add_listener(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Unregister a listener to receive daemon notifications.
|
||||
*
|
||||
* @param listener is the listener to unregister
|
||||
*/
|
||||
virtual void remove_listener(monero_daemon_listener &listener) {
|
||||
throw std::runtime_error("monero_daemon::remove_listener(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the listeners registered with the daemon.
|
||||
*/
|
||||
virtual std::set<monero_daemon_listener*> get_listeners() {
|
||||
throw std::runtime_error("monero_daemon::get_listeners(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove all listeners registered with the daemon.
|
||||
*/
|
||||
virtual void remove_listeners() {
|
||||
throw std::runtime_error("monero_daemon::remove_listeners(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the daemon's version.
|
||||
*
|
||||
* @return the daemon's version
|
||||
*/
|
||||
virtual monero_version get_version() {
|
||||
throw std::runtime_error("monero_daemon::get_version(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Indicates if the daemon is trusted or untrusted.
|
||||
*
|
||||
* @return true if the daemon is trusted, false otherwise
|
||||
*/
|
||||
virtual bool is_trusted() {
|
||||
throw std::runtime_error("monero_daemon::is_trusted(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the number of blocks in the longest chain known to the node.
|
||||
*
|
||||
* @return the number of blocks
|
||||
*/
|
||||
virtual uint64_t get_height() {
|
||||
throw std::runtime_error("monero_daemon::get_height(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a block's hash by its height.
|
||||
*
|
||||
* @param height is the height of the block hash to get
|
||||
* @return tthe block's hash at the given height
|
||||
*/
|
||||
virtual std::string get_block_hash(uint64_t height) {
|
||||
throw std::runtime_error("monero_daemon::get_block_hash(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a block template for mining a new block.
|
||||
*
|
||||
* @param wallet_address is the address of the wallet to receive miner transactions if block is successfully mined
|
||||
* @param reserve_size is the reserve size (optional)
|
||||
* @return a block template for mining a new block
|
||||
*/
|
||||
virtual std::shared_ptr<monero_block_template> get_block_template(const std::string& wallet_address, const boost::optional<int>& reserve_size = boost::none) {
|
||||
throw std::runtime_error("monero_daemon::get_block_template(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the last block's header.
|
||||
*
|
||||
* @return the last block's header
|
||||
*/
|
||||
virtual std::shared_ptr<monero_block_header> get_last_block_header() {
|
||||
throw std::runtime_error("monero_daemon::get_last_block_header(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a block header by its hash.
|
||||
*
|
||||
* @param block_hash is the hash of the block to get the header of
|
||||
* @return the block's header
|
||||
*/
|
||||
virtual std::shared_ptr<monero_block_header> get_block_header_by_hash(const std::string& block_hash) {
|
||||
throw std::runtime_error("monero_daemon::get_block_header_by_hash(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a block header by its height.
|
||||
*
|
||||
* @param height is the height of the block to get the header of
|
||||
* @return the block's header
|
||||
*/
|
||||
virtual std::shared_ptr<monero_block_header> get_block_header_by_height(uint64_t height) {
|
||||
throw std::runtime_error("monero_daemon::get_block_header_by_height(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get block headers for the given range.
|
||||
*
|
||||
* @param start_height is the start height lower bound inclusive (optional)
|
||||
* @param end_height is the end height upper bound inclusive (optional)
|
||||
* @return block headers in the given range
|
||||
*/
|
||||
virtual std::vector<std::shared_ptr<monero_block_header>> get_block_headers_by_range(uint64_t start_height, uint64_t end_height) {
|
||||
throw std::runtime_error("monero_daemon::get_block_headers_by_range(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a block by hash.
|
||||
*
|
||||
* @param block_hash is the hash of the block to get
|
||||
* @return the block with the given hash
|
||||
*/
|
||||
virtual std::shared_ptr<monero_block> get_block_by_hash(const std::string& block_hash) {
|
||||
throw std::runtime_error("monero_daemon::get_block_by_hash(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get blocks by hash.
|
||||
*
|
||||
* @param block_hashes are array of hashes; first 10 blocks hash 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
|
||||
* @param start_height is the start height to get blocks by hash
|
||||
* @param prune specifies if returned blocks should be pruned (defaults to false) // TODO: test default
|
||||
* @return the retrieved blocks
|
||||
*/
|
||||
virtual std::vector<std::shared_ptr<monero_block>> get_blocks_by_hash(const std::vector<std::string>& block_hashes, uint64_t start_height, bool prune) {
|
||||
throw std::runtime_error("monero_daemon::get_blocks_by_hash(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a block by height.
|
||||
*
|
||||
* @param height is the height of the block to get
|
||||
* @return the block at the given height
|
||||
*/
|
||||
virtual std::shared_ptr<monero_block> get_block_by_height(uint64_t height) {
|
||||
throw std::runtime_error("monero_daemon::get_block_by_height(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get blocks at the given heights.
|
||||
*
|
||||
* @param heights are the heights of the blocks to get
|
||||
* @return blocks at the given heights
|
||||
*/
|
||||
virtual std::vector<std::shared_ptr<monero_block>> get_blocks_by_height(const std::vector<uint64_t>& heights) {
|
||||
throw std::runtime_error("monero_daemon::get_blocks_by_height(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get blocks in the given height range.
|
||||
*
|
||||
* @param start_height is the start height lower bound inclusive (optional)
|
||||
* @param end_height is the end height upper bound inclusive (optional)
|
||||
* @return blocks in the given height range
|
||||
*/
|
||||
virtual std::vector<std::shared_ptr<monero_block>> get_blocks_by_range(boost::optional<uint64_t> start_height, boost::optional<uint64_t> end_height) {
|
||||
throw std::runtime_error("monero_daemon::get_blocks_by_range(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get blocks in the given height range as chunked requests so that each request is
|
||||
* not too big.
|
||||
*
|
||||
* @param start_height is the start height lower bound inclusive (optional)
|
||||
* @param end_height is the end height upper bound inclusive (optional)
|
||||
* @return blocks in the given height range
|
||||
*/
|
||||
virtual std::vector<std::shared_ptr<monero_block>> get_blocks_by_range_chunked(boost::optional<uint64_t> start_height, boost::optional<uint64_t> end_height, boost::optional<uint64_t> max_chunk_size) {
|
||||
throw std::runtime_error("monero_daemon::get_blocks_by_range_chunked(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get block hashes as a binary request to the daemon.
|
||||
*
|
||||
* @param block_hashes specify block hashes to fetch; first 10 blocks hash 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
|
||||
* @param start_height is the starting height of block hashes to return
|
||||
* @return the requested block hashes
|
||||
*/
|
||||
virtual std::vector<std::string> get_block_hashes(const std::vector<std::string>& block_hashes, uint64_t start_height) {
|
||||
throw std::runtime_error("monero_daemon::get_block_hashes(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a transaction by hash.
|
||||
*
|
||||
* @param tx_hash is the hash of the transaction to get
|
||||
* @param prune specifies if the returned tx should be pruned (defaults to false)
|
||||
* @return the transaction with the given hash or null if not found
|
||||
*/
|
||||
virtual std::shared_ptr<monero_tx> get_tx(const std::string& tx_hash, bool prune = false) {
|
||||
std::vector<std::string> hashes;
|
||||
hashes.push_back(tx_hash);
|
||||
auto txs = get_txs(hashes, prune);
|
||||
std::shared_ptr<monero_tx> tx;
|
||||
|
||||
if (txs.size() > 0) {
|
||||
tx = txs[0];
|
||||
}
|
||||
|
||||
return tx;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get transactions by hashes.
|
||||
*
|
||||
* @param tx_hashes are hashes of transactions to get
|
||||
* @param prune specifies if the returned txs should be pruned (defaults to false)
|
||||
* @return found transactions with the given hashes
|
||||
*/
|
||||
virtual std::vector<std::shared_ptr<monero_tx>> get_txs(const std::vector<std::string>& tx_hashes, bool prune = false) {
|
||||
throw std::runtime_error("monero_daemon::get_txs(): not supported");
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get a transaction hex by hash.
|
||||
*
|
||||
* @param tx_hash is the hash of the transaction to get hex from
|
||||
* @param prune specifies if the returned tx hex should be pruned (defaults to false)
|
||||
* @return the tx hex with the given hash
|
||||
*/
|
||||
virtual boost::optional<std::string> get_tx_hex(const std::string& tx_hash, bool prune = false) {
|
||||
std::vector<std::string> hashes;
|
||||
hashes.push_back(tx_hash);
|
||||
auto hexes = get_tx_hexes(hashes, prune);
|
||||
boost::optional<std::string> hex;
|
||||
if (hexes.size() > 0) {
|
||||
hex = hexes[0];
|
||||
}
|
||||
|
||||
return hex;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get transaction hexes by hashes.
|
||||
*
|
||||
* @param tx_hashes are hashes of transactions to get hexes from
|
||||
* @param prune specifies if the returned tx hexes should be pruned (defaults to false)
|
||||
* @return are the tx hexes
|
||||
*/
|
||||
virtual std::vector<std::string> get_tx_hexes(const std::vector<std::string>& tx_hashes, bool prune = false) {
|
||||
throw std::runtime_error("monero_daemon::get_tx_hexes(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the total emissions and fees from the genesis block to the current height.
|
||||
*
|
||||
* @param height is the height to start computing the miner sum
|
||||
* @param num_blocks are the number of blocks to include in the sum
|
||||
* @return the sum emission and fees since the geneis block
|
||||
*/
|
||||
virtual std::shared_ptr<monero_miner_tx_sum> get_miner_tx_sum(uint64_t height, uint64_t num_blocks) {
|
||||
throw std::runtime_error("monero_daemon::get_miner_tx_sum(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get mining fee estimates per kB.
|
||||
*
|
||||
* @param grace_blocks TODO
|
||||
* @return mining fee estimates per kB
|
||||
*/
|
||||
virtual std::shared_ptr<monero_fee_estimate> get_fee_estimate(uint64_t grace_blocks = 0) {
|
||||
throw std::runtime_error("monero_daemon::get_fee_estimate(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Submits a transaction to the daemon's pool.
|
||||
*
|
||||
* @param tx_hex is the raw transaction hex to submit
|
||||
* @param do_not_relay specifies if the tx should be relayed (optional)
|
||||
* @return the submission results
|
||||
*/
|
||||
virtual std::shared_ptr<monero_submit_tx_result> submit_tx_hex(const std::string& tx_hex, bool do_not_relay = false) {
|
||||
throw std::runtime_error("monero_daemon::submit_tx_hex(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Relays a transaction by hash.
|
||||
*
|
||||
* @param tx_hash identifies the transaction to relay
|
||||
*/
|
||||
virtual void relay_tx_by_hash(const std::string& tx_hash) {
|
||||
std::vector<std::string> tx_hashes;
|
||||
tx_hashes.push_back(tx_hash);
|
||||
relay_txs_by_hash(tx_hashes);
|
||||
}
|
||||
|
||||
/**
|
||||
* Relays transactions by hash.
|
||||
*
|
||||
* @param tx_hashes identify the transactions to relay
|
||||
*/
|
||||
virtual void relay_txs_by_hash(const std::vector<std::string>& tx_hashes) {
|
||||
throw std::runtime_error("monero_daemon::relay_txs_by_hash(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get valid transactions seen by the node but not yet mined into a block, as well
|
||||
* as spent key image information for the tx pool.
|
||||
*
|
||||
* @return transactions in the transaction pool
|
||||
*/
|
||||
virtual std::vector<std::shared_ptr<monero_tx>> get_tx_pool() {
|
||||
throw std::runtime_error("monero_daemon::get_tx_pool(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get hashes of transactions in the transaction pool.
|
||||
*
|
||||
* @return hashes of transactions in the transaction pool
|
||||
*/
|
||||
virtual std::vector<std::string> get_tx_pool_hashes() {
|
||||
throw std::runtime_error("monero_daemon::get_tx_pool_hashes(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all transaction pool backlog.
|
||||
*
|
||||
* @return transaction pool backlog entries
|
||||
*/
|
||||
virtual std::vector<monero_tx_backlog_entry> get_tx_pool_backlog() {
|
||||
throw std::runtime_error("monero_daemon::get_tx_pool_backlog(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get transaction pool statistics.
|
||||
*
|
||||
* @return statistics about the transaction pool
|
||||
*/
|
||||
virtual std::shared_ptr<monero_tx_pool_stats> get_tx_pool_stats() {
|
||||
throw std::runtime_error("monero_daemon::get_tx_pool_stats(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Flushes all transactions from the tx pool.
|
||||
*/
|
||||
virtual void flush_tx_pool() {
|
||||
throw std::runtime_error("monero_daemon::flush_tx_pool(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Flush transactions from the tx pool.
|
||||
*
|
||||
* @param hashes are hashes of transactions to flush
|
||||
*/
|
||||
virtual void flush_tx_pool(const std::vector<std::string> &hashes) {
|
||||
throw std::runtime_error("monero_daemon::flush_tx_pool(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Flush a single transaction from the tx pool.
|
||||
*
|
||||
* @param hash is the hash of transaction to flush
|
||||
*/
|
||||
virtual void flush_tx_pool(const std::string &hash) {
|
||||
throw std::runtime_error("monero_daemon::flush_tx_pool(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the spent status of the given key image.
|
||||
*
|
||||
* @param key_image is key image hex to get the status of
|
||||
* @return the status of the key image
|
||||
*/
|
||||
virtual monero_key_image_spent_status get_key_image_spent_status(const std::string& key_image) {
|
||||
std::vector<std::string> key_images;
|
||||
key_images.push_back(key_image);
|
||||
auto statuses = get_key_image_spent_statuses(key_images);
|
||||
if (statuses.empty()) throw std::runtime_error("Could not get key image spent status");
|
||||
return statuses[0];
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the spent status of each given key image.
|
||||
*
|
||||
* @param key_image are hex key images to get the statuses of
|
||||
* @return the spent status for each key image
|
||||
*/
|
||||
virtual std::vector<monero_key_image_spent_status> get_key_image_spent_statuses(const std::vector<std::string>& key_images) {
|
||||
throw std::runtime_error("monero_daemon::get_key_image_spent_statuses(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get outputs identified by a list of output amounts and indices as a binary
|
||||
* request.
|
||||
*
|
||||
* @param outputs identify each output by amount and index
|
||||
* @return the identified outputs
|
||||
*/
|
||||
virtual std::vector<std::shared_ptr<monero_output>> get_outputs(const std::vector<monero_output>& outputs) {
|
||||
throw std::runtime_error("monero_daemon::get_outputs(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a histogram of output amounts. For all amounts (possibly filtered by
|
||||
* parameters), gives the number of outputs on the chain for that amount.
|
||||
* RingCT outputs counts as 0 amount.
|
||||
*
|
||||
* @param amounts are amounts of outputs to make the histogram with
|
||||
* @param min_count TODO
|
||||
* @param max_count TODO
|
||||
* @param is_unlocked makes a histogram with outputs with the specified lock state
|
||||
* @param recent_cutoff TODO
|
||||
* @return output histogram entries meeting the parameters
|
||||
*/
|
||||
virtual std::vector<std::shared_ptr<monero_output_histogram_entry>> get_output_histogram(const std::vector<uint64_t>& amounts, const boost::optional<int>& min_count, const boost::optional<int>& max_count, const boost::optional<bool>& is_unlocked, const boost::optional<int>& recent_cutoff) {
|
||||
throw std::runtime_error("monero_daemon::get_output_histogram(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an output distribution.
|
||||
*
|
||||
* @param amounts are amounts of outputs to make the distribution with
|
||||
* @param is_cumulative specifies if the results should be cumulative (defaults to TODO)
|
||||
* @param start_height is the start height lower bound inclusive (optional)
|
||||
* @param end_height is the end height upper bound inclusive (optional)
|
||||
* @return output distribution entries meeting the parameters
|
||||
*/
|
||||
virtual std::vector<std::shared_ptr<monero_output_distribution_entry>> get_output_distribution(const std::vector<uint64_t>& amounts, const boost::optional<bool>& is_cumulative = boost::none, const boost::optional<uint64_t>& start_height = boost::none, const boost::optional<uint64_t>& end_height = boost::none) {
|
||||
throw std::runtime_error("monero_daemon::get_output_distribution(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get general information about the state of the node and the network.
|
||||
*
|
||||
* @return general information about the node and network
|
||||
*/
|
||||
virtual std::shared_ptr<monero_daemon_info> get_info() {
|
||||
throw std::runtime_error("monero_daemon::get_info(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get synchronization information.
|
||||
*
|
||||
* @return contains sync information
|
||||
*/
|
||||
virtual std::shared_ptr<monero_daemon_sync_info> get_sync_info() {
|
||||
throw std::runtime_error("monero_daemon::get_sync_info(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Look up information regarding hard fork voting and readiness.
|
||||
*
|
||||
* @return hard fork information
|
||||
*/
|
||||
virtual std::shared_ptr<monero_hard_fork_info> get_hard_fork_info() {
|
||||
throw std::runtime_error("monero_daemon::get_hard_fork_info(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get alternative chains seen by the node.
|
||||
*
|
||||
* @return alternative chains seen by the node
|
||||
*/
|
||||
virtual std::vector<std::shared_ptr<monero_alt_chain>> get_alt_chains() {
|
||||
throw std::runtime_error("monero_daemon::get_alt_chains(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get known block hashes which are not on the main chain.
|
||||
*
|
||||
* @return known block hashes which are not on the main chain
|
||||
*/
|
||||
virtual std::vector<std::string> get_alt_block_hashes() {
|
||||
throw std::runtime_error("monero_daemon::get_alt_block_hashes(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the download bandwidth limit.
|
||||
*
|
||||
* @return is the download bandwidth limit
|
||||
*/
|
||||
virtual int get_download_limit() {
|
||||
throw std::runtime_error("monero_daemon::get_download_limit(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the download bandwidth limit.
|
||||
*
|
||||
* @param limit is the download limit to set (-1 to reset to default)
|
||||
* @return int is the new download limit after setting
|
||||
*/
|
||||
virtual int set_download_limit(int limit) {
|
||||
throw std::runtime_error("monero_daemon::set_download_limit(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset the download bandwidth limit.
|
||||
*
|
||||
* @return the download bandwidth limit after resetting
|
||||
*/
|
||||
virtual int reset_download_limit() {
|
||||
throw std::runtime_error("monero_daemon::reset_download_limit(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the upload bandwidth limit.
|
||||
*
|
||||
* @return is the upload bandwidth limit
|
||||
*/
|
||||
virtual int get_upload_limit() {
|
||||
throw std::runtime_error("monero_daemon::get_upload_limit(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the upload bandwidth limit.
|
||||
*
|
||||
* @param limit is the upload limit to set (-1 to reset to default)
|
||||
* @return int is the new upload limit after setting
|
||||
*/
|
||||
virtual int set_upload_limit(int limit) {
|
||||
throw std::runtime_error("monero_daemon::set_upload_limit(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset the upload bandwidth limit.
|
||||
*
|
||||
* @return the upload bandwidth limit after resetting
|
||||
*/
|
||||
virtual int reset_upload_limit() {
|
||||
throw std::runtime_error("monero_daemon::reset_upload_limit(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get peers with active incoming or outgoing connections to the node.
|
||||
*
|
||||
* @return the daemon's peers
|
||||
*/
|
||||
virtual std::vector<std::shared_ptr<monero_peer>> get_peers() {
|
||||
throw std::runtime_error("monero_daemon::get_peers(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all known peers including their last known online status.
|
||||
*
|
||||
* @return the daemon's known peers
|
||||
*/
|
||||
virtual std::vector<std::shared_ptr<monero_peer>> get_known_peers() {
|
||||
throw std::runtime_error("monero_daemon::get_known_peers(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Limit number of outgoing peers.
|
||||
*
|
||||
* @param limit is the maximum number of outgoing peers
|
||||
*/
|
||||
virtual void set_outgoing_peer_limit(int limit) {
|
||||
throw std::runtime_error("monero_daemon::set_outgoing_peer_limit(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Limit number of incoming peers.
|
||||
*
|
||||
* @param limit is the maximum number of incoming peers
|
||||
*/
|
||||
virtual void set_incoming_peer_limit(int limit) {
|
||||
throw std::runtime_error("monero_daemon::set_incoming_peer_limit(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get peer bans.
|
||||
*
|
||||
* @return entries about banned peers
|
||||
*/
|
||||
virtual std::vector<std::shared_ptr<monero_ban>> get_peer_bans() {
|
||||
throw std::runtime_error("monero_daemon::get_peer_bans(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Ban peers nodes.
|
||||
*
|
||||
* @param bans are bans to apply against peer nodes
|
||||
*/
|
||||
virtual void set_peer_bans(const std::vector<std::shared_ptr<monero_ban>>& bans) {
|
||||
throw std::runtime_error("monero_daemon::set_peer_bans(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Ban a peer node.
|
||||
*
|
||||
* @param ban contains information about a node to ban
|
||||
*/
|
||||
virtual void set_peer_ban(const std::shared_ptr<monero_ban>& ban) {
|
||||
if (ban == nullptr) throw std::runtime_error("Ban is none");
|
||||
std::vector<std::shared_ptr<monero_ban>> bans;
|
||||
bans.push_back(ban);
|
||||
set_peer_bans(bans);
|
||||
}
|
||||
|
||||
/**
|
||||
* Start mining.
|
||||
*
|
||||
* @param address is the address given miner rewards if the daemon mines a block
|
||||
* @param num_threads is the number of mining threads to run
|
||||
* @param is_background specifies if the miner should run in the background or not
|
||||
* @param ignore_battery specifies if the battery state (e.g. on laptop) should be ignored or not
|
||||
*/
|
||||
virtual void start_mining(const std::string &address, boost::optional<uint64_t> num_threads, boost::optional<bool> is_background, boost::optional<bool> ignore_battery) {
|
||||
throw std::runtime_error("monero_daemon::start_mining(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Stop mining.
|
||||
*/
|
||||
virtual void stop_mining() {
|
||||
throw std::runtime_error("monero_daemon::stop_mining(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the daemon's mining status.
|
||||
*
|
||||
* @return the daemon's mining status
|
||||
*/
|
||||
virtual std::shared_ptr<monero_mining_status> get_mining_status() {
|
||||
throw std::runtime_error("monero_daemon::get_mining_status(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate blocks to a wallet address (regtest only).
|
||||
*
|
||||
* @param wallet_address is the address of the wallet to receive miner transactions if block is successfully mined
|
||||
* @param num_blocks is the number of blocks to generate
|
||||
* @param prev_block_hash is the hash of the previous block to build on top of (optional, builds on the current tip if not given)
|
||||
* @param starting_nonce is the starting nonce to use (optional)
|
||||
* @return the result of generating blocks; height is the height of the last block generated
|
||||
*/
|
||||
virtual std::shared_ptr<monero_generate_blocks_result> generate_blocks(const std::string& wallet_address, uint64_t num_blocks, const boost::optional<std::string>& prev_block_hash = boost::none, const boost::optional<uint32_t>& starting_nonce = boost::none) {
|
||||
throw std::runtime_error("monero_daemon::generate_blocks(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Submit a mined block to the network.
|
||||
*
|
||||
* @param block_blob is the mined block to submit
|
||||
*/
|
||||
virtual void submit_block(const std::string& block_blob) {
|
||||
std::vector<std::string> block_blobs;
|
||||
block_blobs.push_back(block_blob);
|
||||
return submit_blocks(block_blobs);
|
||||
}
|
||||
|
||||
/**
|
||||
* Submit mined blocks to the network.
|
||||
*
|
||||
* @param block_blobs are the mined blocks to submit
|
||||
*/
|
||||
virtual void submit_blocks(const std::vector<std::string>& block_blobs) {
|
||||
throw std::runtime_error("monero_daemon::submit_blocks(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Prune the blockchain.
|
||||
*
|
||||
* @param check specifies to check the pruning (default false)
|
||||
* @return the prune result
|
||||
*/
|
||||
virtual std::shared_ptr<monero_prune_result> prune_blockchain(bool check) {
|
||||
throw std::runtime_error("monero_daemon::prune_blockchain(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Check for update.
|
||||
*
|
||||
* @return the result of the update check
|
||||
*/
|
||||
virtual std::shared_ptr<monero_daemon_update_check_result> check_for_update() {
|
||||
throw std::runtime_error("monero_daemon::check_for_update(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Download an update.
|
||||
*
|
||||
* @param path is the path to download the update (optional)
|
||||
* @return the result of the update download
|
||||
*/
|
||||
virtual std::shared_ptr<monero_daemon_update_download_result> download_update(const std::string& path = "") {
|
||||
throw std::runtime_error("monero_daemon::download_update(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Safely disconnect and shut down the daemon.
|
||||
*/
|
||||
virtual void stop() {
|
||||
throw std::runtime_error("monero_daemon::stop(): not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the header of the next block added to the chain.
|
||||
*
|
||||
* @return the header of the next block added to the chain
|
||||
*/
|
||||
virtual std::shared_ptr<monero_block_header> wait_for_next_block_header() {
|
||||
throw std::runtime_error("monero_daemon::wait_for_next_block_header(): not supported");
|
||||
}
|
||||
|
||||
};
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,639 @@
|
||||
/**
|
||||
* Copyright (c) woodser
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*
|
||||
* Parts of this file are originally copyright (c) 2014-2019, The Monero Project
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification, are
|
||||
* permitted provided that the following conditions are met:
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
* 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 <map>
|
||||
#include <boost/property_tree/ptree.hpp>
|
||||
#include <boost/property_tree/json_parser.hpp>
|
||||
#include "rapidjson/document.h"
|
||||
#include "rapidjson/writer.h"
|
||||
#include "rapidjson/stringbuffer.h"
|
||||
|
||||
/**
|
||||
* Public interface for libmonero-cpp library.
|
||||
*/
|
||||
namespace monero {
|
||||
|
||||
/**
|
||||
* Base struct which can be serialized.
|
||||
*/
|
||||
struct serializable_struct {
|
||||
|
||||
virtual ~serializable_struct() = default;
|
||||
|
||||
/**
|
||||
* Serializes the struct to a json std::string.
|
||||
*
|
||||
* @return the struct serialized to a json std::string
|
||||
*/
|
||||
std::string serialize() const;
|
||||
|
||||
/**
|
||||
* Converts the struct to a rapidjson Value.
|
||||
*
|
||||
* @param allocator is the rapidjson document allocator
|
||||
* @return the struct as a rapidjson Value
|
||||
*/
|
||||
virtual rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const = 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Models connection ssl options.
|
||||
*/
|
||||
struct ssl_options : public serializable_struct {
|
||||
boost::optional<std::string> m_ssl_private_key_path;
|
||||
boost::optional<std::string> m_ssl_certificate_path;
|
||||
boost::optional<std::string> m_ssl_ca_file;
|
||||
std::vector<std::string> m_ssl_allowed_fingerprints;
|
||||
boost::optional<bool> m_ssl_allow_any_cert;
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
/**
|
||||
* Enumerates Monero connection types.
|
||||
*/
|
||||
enum monero_connection_type : uint8_t {
|
||||
INVALID = 0,
|
||||
IPV4,
|
||||
IPV6,
|
||||
TOR,
|
||||
I2P
|
||||
};
|
||||
|
||||
/**
|
||||
* Enumerates Monero network types.
|
||||
*/
|
||||
enum monero_network_type : uint8_t {
|
||||
MAINNET = 0,
|
||||
TESTNET,
|
||||
STAGENET
|
||||
};
|
||||
|
||||
/**
|
||||
* Models connection bandwidth limits.
|
||||
*/
|
||||
struct monero_bandwidth_limits : public serializable_struct {
|
||||
boost::optional<int> m_up;
|
||||
boost::optional<int> m_down;
|
||||
|
||||
monero_bandwidth_limits() { }
|
||||
monero_bandwidth_limits(int up, int down): m_up(up), m_down(down) { }
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_bandwidth_limits>& limits);
|
||||
};
|
||||
|
||||
/**
|
||||
* Models a Monero version.
|
||||
*/
|
||||
struct monero_version : public serializable_struct {
|
||||
boost::optional<uint32_t> m_number;
|
||||
boost::optional<bool> m_is_release;
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_version>& version);
|
||||
};
|
||||
|
||||
// forward declarations
|
||||
struct monero_tx;
|
||||
struct monero_output;
|
||||
|
||||
/**
|
||||
* Models a Monero block header which contains information about the block.
|
||||
*
|
||||
* TODO: a header that is transmitted may have fewer fields like cryptonote::block_header; separate?
|
||||
*/
|
||||
struct monero_block_header : public serializable_struct {
|
||||
boost::optional<std::string> m_hash;
|
||||
boost::optional<uint64_t> m_height;
|
||||
boost::optional<uint64_t> m_timestamp;
|
||||
boost::optional<uint64_t> m_size;
|
||||
boost::optional<uint64_t> m_weight;
|
||||
boost::optional<uint64_t> m_long_term_weight;
|
||||
boost::optional<uint64_t> m_depth;
|
||||
boost::optional<uint64_t> m_difficulty_low;
|
||||
boost::optional<uint64_t> m_difficulty_high;
|
||||
boost::optional<uint64_t> m_cumulative_difficulty_low;
|
||||
boost::optional<uint64_t> m_cumulative_difficulty_high;
|
||||
boost::optional<uint32_t> m_major_version;
|
||||
boost::optional<uint32_t> m_minor_version;
|
||||
boost::optional<uint32_t> m_nonce;
|
||||
boost::optional<std::string> m_miner_tx_hash;
|
||||
boost::optional<uint32_t> m_num_txs;
|
||||
boost::optional<bool> m_orphan_status;
|
||||
boost::optional<std::string> m_prev_hash;
|
||||
boost::optional<uint64_t> m_reward;
|
||||
boost::optional<std::string> m_pow_hash;
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
|
||||
std::shared_ptr<monero_block_header> copy(const std::shared_ptr<monero_block_header>& src, const std::shared_ptr<monero_block_header>& tgt) const;
|
||||
virtual void merge(const std::shared_ptr<monero_block_header>& self, const std::shared_ptr<monero_block_header>& other);
|
||||
};
|
||||
|
||||
/**
|
||||
* Models a Monero block in the blockchain.
|
||||
*/
|
||||
struct monero_block : public monero_block_header {
|
||||
boost::optional<std::string> m_hex;
|
||||
std::shared_ptr<monero_tx> m_miner_tx;
|
||||
std::vector<std::shared_ptr<monero_tx>> m_txs;
|
||||
std::vector<std::string> m_tx_hashes;
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
|
||||
std::shared_ptr<monero_block> copy(const std::shared_ptr<monero_block>& src, const std::shared_ptr<monero_block>& tgt) const;
|
||||
void merge(const std::shared_ptr<monero_block_header>& self, const std::shared_ptr<monero_block_header>& other);
|
||||
void merge(const std::shared_ptr<monero_block>& self, const std::shared_ptr<monero_block>& other);
|
||||
};
|
||||
|
||||
/**
|
||||
* Models a Monero transaction on the blockchain.
|
||||
*/
|
||||
struct monero_tx : public serializable_struct {
|
||||
static const std::string DEFAULT_PAYMENT_ID; // default payment id "0000000000000000"
|
||||
static const std::string DEFAULT_ID;
|
||||
|
||||
std::shared_ptr<monero_block> m_block;
|
||||
boost::optional<std::string> m_hash;
|
||||
boost::optional<uint32_t> m_version;
|
||||
boost::optional<bool> m_is_miner_tx;
|
||||
boost::optional<std::string> m_payment_id;
|
||||
boost::optional<uint64_t> m_fee;
|
||||
boost::optional<uint32_t> m_ring_size;
|
||||
boost::optional<bool> m_relay;
|
||||
boost::optional<bool> m_is_relayed;
|
||||
boost::optional<bool> m_is_confirmed;
|
||||
boost::optional<bool> m_in_tx_pool;
|
||||
boost::optional<uint64_t> m_num_confirmations;
|
||||
boost::optional<uint64_t> m_unlock_time;
|
||||
boost::optional<uint64_t> m_last_relayed_timestamp;
|
||||
boost::optional<uint64_t> m_received_timestamp;
|
||||
boost::optional<bool> m_is_double_spend_seen;
|
||||
boost::optional<std::string> m_key;
|
||||
boost::optional<std::string> m_full_hex;
|
||||
boost::optional<std::string> m_pruned_hex;
|
||||
boost::optional<std::string> m_prunable_hex;
|
||||
boost::optional<std::string> m_prunable_hash;
|
||||
boost::optional<uint64_t> m_size;
|
||||
boost::optional<uint64_t> m_weight;
|
||||
std::vector<std::shared_ptr<monero_output>> m_inputs;
|
||||
std::vector<std::shared_ptr<monero_output>> m_outputs;
|
||||
std::vector<uint64_t> m_output_indices;
|
||||
boost::optional<std::string> m_metadata;
|
||||
boost::optional<std::string> m_common_tx_sets;
|
||||
std::vector<uint8_t> m_extra;
|
||||
boost::optional<std::string> m_rct_signatures; // TODO: implement
|
||||
boost::optional<std::string> m_rct_sig_prunable; // TODO: implement
|
||||
boost::optional<bool> m_is_kept_by_block;
|
||||
boost::optional<bool> m_is_failed;
|
||||
boost::optional<uint64_t> m_last_failed_height;
|
||||
boost::optional<std::string> m_last_failed_hash;
|
||||
boost::optional<uint64_t> m_max_used_block_height;
|
||||
boost::optional<std::string> m_max_used_block_hash;
|
||||
std::vector<std::string> m_signatures;
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, std::shared_ptr<monero_tx> tx);
|
||||
std::shared_ptr<monero_tx> copy(const std::shared_ptr<monero_tx>& src, const std::shared_ptr<monero_tx>& tgt) const;
|
||||
virtual void merge(const std::shared_ptr<monero_tx>& self, const std::shared_ptr<monero_tx>& other);
|
||||
boost::optional<uint64_t> get_height() const;
|
||||
};
|
||||
|
||||
/**
|
||||
* Models a Monero key image.
|
||||
*/
|
||||
struct monero_key_image : public serializable_struct {
|
||||
boost::optional<std::string> m_hex;
|
||||
boost::optional<std::string> m_signature;
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_key_image>& key_image);
|
||||
static std::vector<std::shared_ptr<monero_key_image>> deserialize_key_images(const std::string& key_images_json); // TODO: remove this specialty util used once
|
||||
std::shared_ptr<monero_key_image> copy(const std::shared_ptr<monero_key_image>& src, const std::shared_ptr<monero_key_image>& tgt) const;
|
||||
void merge(const std::shared_ptr<monero_key_image>& self, const std::shared_ptr<monero_key_image>& other);
|
||||
};
|
||||
|
||||
/**
|
||||
* Models a Monero transaction output.
|
||||
*/
|
||||
struct monero_output : public serializable_struct {
|
||||
std::shared_ptr<monero_tx> m_tx;
|
||||
std::shared_ptr<monero_key_image> m_key_image;
|
||||
boost::optional<uint64_t> m_amount;
|
||||
boost::optional<uint64_t> m_index;
|
||||
std::vector<uint64_t> m_ring_output_indices;
|
||||
boost::optional<std::string> m_stealth_public_key;
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_output>& output);
|
||||
std::shared_ptr<monero_output> copy(const std::shared_ptr<monero_output>& src, const std::shared_ptr<monero_output>& tgt) const;
|
||||
virtual void merge(const std::shared_ptr<monero_output>& self, const std::shared_ptr<monero_output>& other);
|
||||
};
|
||||
|
||||
/**
|
||||
* Models the status of a Monero key image.
|
||||
*/
|
||||
enum monero_key_image_spent_status : uint8_t {
|
||||
NOT_SPENT = 0,
|
||||
CONFIRMED,
|
||||
TX_POOL
|
||||
};
|
||||
|
||||
/**
|
||||
* Models a Monero RPC payment information.
|
||||
*/
|
||||
struct monero_rpc_payment_info : public serializable_struct {
|
||||
boost::optional<uint64_t> m_credits;
|
||||
boost::optional<std::string> m_top_block_hash;
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_rpc_payment_info>& rpc_payment_info);
|
||||
};
|
||||
|
||||
/**
|
||||
* Models an alternative chain seen by the node.
|
||||
*/
|
||||
struct monero_alt_chain : public serializable_struct {
|
||||
std::vector<std::string> m_block_hashes;
|
||||
boost::optional<uint64_t> m_difficulty_low;
|
||||
boost::optional<uint64_t> m_difficulty_high;
|
||||
boost::optional<uint64_t> m_height;
|
||||
boost::optional<uint64_t> m_length;
|
||||
boost::optional<std::string> m_main_chain_parent_block_hash;
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_alt_chain>& alt_chain);
|
||||
};
|
||||
|
||||
/**
|
||||
* Monero banhammer.
|
||||
*/
|
||||
struct monero_ban : public serializable_struct {
|
||||
boost::optional<std::string> m_host;
|
||||
boost::optional<uint32_t> m_ip;
|
||||
boost::optional<bool> m_is_banned;
|
||||
boost::optional<uint64_t> m_seconds;
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_ban>& ban);
|
||||
};
|
||||
|
||||
/**
|
||||
* Result of pruning the blockchain.
|
||||
*/
|
||||
struct monero_prune_result : public serializable_struct {
|
||||
boost::optional<bool> m_is_pruned;
|
||||
boost::optional<int> m_pruning_seed;
|
||||
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_prune_result>& result);
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
/**
|
||||
* Monero daemon mining status.
|
||||
*/
|
||||
struct monero_mining_status : public serializable_struct {
|
||||
boost::optional<bool> m_is_active;
|
||||
boost::optional<bool> m_is_background;
|
||||
boost::optional<std::string> m_address;
|
||||
boost::optional<uint64_t> m_speed;
|
||||
boost::optional<int> m_num_threads;
|
||||
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_mining_status>& status);
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
/**
|
||||
* Model for the summation of miner emissions and fees.
|
||||
*/
|
||||
struct monero_miner_tx_sum : public serializable_struct {
|
||||
boost::optional<uint64_t> m_emission_sum_low;
|
||||
boost::optional<uint64_t> m_emission_sum_high;
|
||||
boost::optional<uint64_t> m_fee_sum_low;
|
||||
boost::optional<uint64_t> m_fee_sum_high;
|
||||
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_miner_tx_sum>& sum);
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
/**
|
||||
* Monero block template to mine.
|
||||
*/
|
||||
struct monero_block_template : public serializable_struct {
|
||||
boost::optional<std::string> m_block_template_blob;
|
||||
boost::optional<std::string> m_block_hashing_blob;
|
||||
boost::optional<std::string> m_prev_hash;
|
||||
boost::optional<std::string> m_seed_hash;
|
||||
boost::optional<std::string> m_next_seed_hash;
|
||||
boost::optional<uint64_t> m_difficulty_low;
|
||||
boost::optional<uint64_t> m_difficulty_high;
|
||||
boost::optional<uint64_t> m_expected_reward;
|
||||
boost::optional<uint64_t> m_height;
|
||||
boost::optional<uint64_t> m_reserved_offset;
|
||||
boost::optional<uint64_t> m_seed_height;
|
||||
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_block_template>& tmplt);
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
/**
|
||||
* Monero daemon connection span.
|
||||
*/
|
||||
struct monero_connection_span : public serializable_struct {
|
||||
boost::optional<std::string> m_connection_id;
|
||||
boost::optional<std::string> m_remote_address;
|
||||
boost::optional<uint64_t> m_num_blocks;
|
||||
boost::optional<uint64_t> m_rate;
|
||||
boost::optional<uint64_t> m_speed;
|
||||
boost::optional<uint64_t> m_size;
|
||||
boost::optional<uint64_t> m_start_height;
|
||||
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_connection_span>& span);
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
/**
|
||||
* Models a peer to the daemon.
|
||||
*/
|
||||
struct monero_peer : public serializable_struct {
|
||||
boost::optional<std::string> m_id;
|
||||
boost::optional<std::string> m_address;
|
||||
boost::optional<std::string> m_host;
|
||||
boost::optional<int> m_port;
|
||||
boost::optional<bool> m_is_online;
|
||||
boost::optional<uint64_t> m_last_seen_timestamp;
|
||||
boost::optional<int> m_pruning_seed;
|
||||
boost::optional<int> m_rpc_port;
|
||||
boost::optional<uint64_t> m_rpc_credits_per_hash;
|
||||
boost::optional<std::string> m_hash;
|
||||
boost::optional<uint64_t> m_avg_download;
|
||||
boost::optional<uint64_t> m_avg_upload;
|
||||
boost::optional<uint64_t> m_current_download;
|
||||
boost::optional<uint64_t> m_current_upload;
|
||||
boost::optional<uint64_t> m_height;
|
||||
boost::optional<bool> m_is_incoming;
|
||||
boost::optional<uint64_t> m_live_time;
|
||||
boost::optional<bool> m_is_local_ip;
|
||||
boost::optional<bool> m_is_local_host;
|
||||
boost::optional<uint64_t> m_num_receives;
|
||||
boost::optional<uint64_t> m_num_sends;
|
||||
boost::optional<uint64_t> m_receive_idle_time;
|
||||
boost::optional<uint64_t> m_send_idle_time;
|
||||
boost::optional<std::string> m_state;
|
||||
boost::optional<int> m_num_support_flags;
|
||||
boost::optional<monero_connection_type> m_connection_type;
|
||||
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_peer>& peer);
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
/**
|
||||
* Models the result from submitting a tx to a daemon.
|
||||
*/
|
||||
struct monero_submit_tx_result : public monero_rpc_payment_info {
|
||||
boost::optional<bool> m_has_invalid_input;
|
||||
boost::optional<bool> m_has_invalid_output;
|
||||
boost::optional<bool> m_has_too_few_outputs;
|
||||
boost::optional<bool> m_is_good;
|
||||
boost::optional<bool> m_is_relayed;
|
||||
boost::optional<bool> m_is_double_spend;
|
||||
boost::optional<bool> m_is_fee_too_low;
|
||||
boost::optional<bool> m_is_mixin_too_low;
|
||||
boost::optional<bool> m_is_overspend;
|
||||
boost::optional<bool> m_is_too_big;
|
||||
boost::optional<bool> m_sanity_check_failed;
|
||||
boost::optional<bool> m_is_tx_extra_too_big;
|
||||
boost::optional<bool> m_is_nonzero_unlock_time;
|
||||
boost::optional<std::string> m_reason;
|
||||
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_submit_tx_result>& result);
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
/**
|
||||
* TODO.
|
||||
*/
|
||||
struct monero_tx_backlog_entry {
|
||||
// TODO
|
||||
};
|
||||
|
||||
/**
|
||||
* Monero output distribution entry.
|
||||
*/
|
||||
struct monero_output_distribution_entry : public serializable_struct {
|
||||
boost::optional<uint64_t> m_amount;
|
||||
boost::optional<uint64_t> m_base;
|
||||
std::vector<uint64_t> m_distribution;
|
||||
boost::optional<uint64_t> m_start_height;
|
||||
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_output_distribution_entry>& entry);
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
/**
|
||||
* Entry in a Monero output histogram (see get_output_histogram of Daemon RPC documentation).
|
||||
*/
|
||||
struct monero_output_histogram_entry : public serializable_struct {
|
||||
boost::optional<uint64_t> m_amount;
|
||||
boost::optional<uint64_t> m_num_instances;
|
||||
boost::optional<uint64_t> m_unlocked_instances;
|
||||
boost::optional<uint64_t> m_recent_instances;
|
||||
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_output_histogram_entry>& entry);
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
/**
|
||||
* Models transaction pool statistics.
|
||||
*/
|
||||
struct monero_tx_pool_stats : public serializable_struct {
|
||||
boost::optional<int> m_num_txs;
|
||||
boost::optional<int> m_num_not_relayed;
|
||||
boost::optional<int> m_num_failing;
|
||||
boost::optional<int> m_num_double_spends;
|
||||
boost::optional<int> m_num10m;
|
||||
boost::optional<uint64_t> m_fee_total;
|
||||
boost::optional<uint64_t> m_bytes_max;
|
||||
boost::optional<uint64_t> m_bytes_med;
|
||||
boost::optional<uint64_t> m_bytes_min;
|
||||
boost::optional<uint64_t> m_bytes_total;
|
||||
std::map<uint64_t, uint64_t> m_histo;
|
||||
boost::optional<uint64_t> m_histo98pc;
|
||||
boost::optional<uint64_t> m_oldest_timestamp;
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_tx_pool_stats>& stats);
|
||||
};
|
||||
|
||||
/**
|
||||
* Models the result of checking for a daemon update.
|
||||
*/
|
||||
struct monero_daemon_update_check_result : public serializable_struct {
|
||||
boost::optional<bool> m_is_update_available;
|
||||
boost::optional<std::string> m_version;
|
||||
boost::optional<std::string> m_hash;
|
||||
boost::optional<std::string> m_auto_uri;
|
||||
boost::optional<std::string> m_user_uri;
|
||||
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_daemon_update_check_result>& check);
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
/**
|
||||
* Models the result of downloading an update.
|
||||
*/
|
||||
struct monero_daemon_update_download_result : public monero_daemon_update_check_result {
|
||||
boost::optional<std::string> m_download_path;
|
||||
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_daemon_update_download_result>& check);
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
/**
|
||||
* Models a Monero fee estimate.
|
||||
*/
|
||||
struct monero_fee_estimate : public serializable_struct {
|
||||
boost::optional<uint64_t> m_quantization_mask;
|
||||
boost::optional<uint64_t> m_fee;
|
||||
std::vector<uint64_t> m_fees;
|
||||
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_fee_estimate>& estimate);
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
/**
|
||||
* Monero daemon info.
|
||||
*/
|
||||
struct monero_daemon_info : public monero_rpc_payment_info {
|
||||
boost::optional<std::string> m_version;
|
||||
boost::optional<uint64_t> m_num_alt_blocks;
|
||||
boost::optional<uint64_t> m_block_size_limit;
|
||||
boost::optional<uint64_t> m_block_size_median;
|
||||
boost::optional<uint64_t> m_block_weight_limit;
|
||||
boost::optional<uint64_t> m_block_weight_median;
|
||||
boost::optional<std::string> m_bootstrap_daemon_address;
|
||||
boost::optional<uint64_t> m_difficulty_low;
|
||||
boost::optional<uint64_t> m_difficulty_high;
|
||||
boost::optional<uint64_t> m_cumulative_difficulty_low;
|
||||
boost::optional<uint64_t> m_cumulative_difficulty_high;
|
||||
boost::optional<uint64_t> m_free_space;
|
||||
boost::optional<int> m_num_offline_peers;
|
||||
boost::optional<int> m_num_online_peers;
|
||||
boost::optional<uint64_t> m_height;
|
||||
boost::optional<uint64_t> m_height_without_bootstrap;
|
||||
boost::optional<monero_network_type> m_network_type;
|
||||
boost::optional<bool> m_is_offline;
|
||||
boost::optional<int> m_num_incoming_connections;
|
||||
boost::optional<int> m_num_outgoing_connections;
|
||||
boost::optional<int> m_num_rpc_connections;
|
||||
boost::optional<uint64_t> m_start_timestamp;
|
||||
boost::optional<uint64_t> m_adjusted_timestamp;
|
||||
boost::optional<uint64_t> m_target;
|
||||
boost::optional<uint64_t> m_target_height;
|
||||
boost::optional<int> m_num_txs;
|
||||
boost::optional<int> m_num_txs_pool;
|
||||
boost::optional<bool> m_was_bootstrap_ever_used;
|
||||
boost::optional<uint64_t> m_database_size;
|
||||
boost::optional<bool> m_update_available;
|
||||
boost::optional<bool> m_is_busy_syncing;
|
||||
boost::optional<bool> m_is_synchronized;
|
||||
boost::optional<bool> m_is_restricted;
|
||||
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_daemon_info>& info);
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
/**
|
||||
* Models daemon synchronization information.
|
||||
*/
|
||||
struct monero_daemon_sync_info : public monero_rpc_payment_info {
|
||||
boost::optional<std::string> m_overview;
|
||||
boost::optional<uint64_t> m_height;
|
||||
boost::optional<uint64_t> m_target_height;
|
||||
boost::optional<int> m_next_needed_pruning_seed;
|
||||
std::vector<std::shared_ptr<monero_peer>> m_peers;
|
||||
std::vector<std::shared_ptr<monero_connection_span>> m_spans;
|
||||
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_daemon_sync_info>& info);
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
/**
|
||||
* Monero hard fork info.
|
||||
*/
|
||||
struct monero_hard_fork_info : public monero_rpc_payment_info {
|
||||
boost::optional<bool> m_is_enabled;
|
||||
boost::optional<uint64_t> m_earliest_height;
|
||||
boost::optional<int> m_state;
|
||||
boost::optional<int> m_threshold;
|
||||
boost::optional<int> m_version;
|
||||
boost::optional<int> m_num_votes;
|
||||
boost::optional<int> m_window;
|
||||
boost::optional<int> m_voting;
|
||||
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_hard_fork_info>& info);
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
/**
|
||||
* Models the result of generating blocks.
|
||||
*/
|
||||
struct monero_generate_blocks_result : public serializable_struct {
|
||||
std::vector<std::string> m_block_hashes;
|
||||
boost::optional<uint64_t> m_height;
|
||||
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_generate_blocks_result>& result);
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
}
|
||||
@@ -0,0 +1,892 @@
|
||||
/**
|
||||
* Copyright (c) everoddandeven
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*
|
||||
* Parts of this file are originally copyright (c) 2025-2026 woodser
|
||||
*
|
||||
* Parts of this file are originally copyright (c) 2014-2019, The Monero Project
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification, are
|
||||
* permitted provided that the following conditions are met:
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
* 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
|
||||
*/
|
||||
#include "monero_daemon_rpc.h"
|
||||
#include "monero_daemon_rpc_model.h"
|
||||
#include "common/monero_error.h"
|
||||
#include "utils/gen_utils.h"
|
||||
#include "utils/monero_utils.h"
|
||||
|
||||
static const uint64_t MAX_REQ_SIZE = 3000000;
|
||||
static const uint64_t NUM_HEADERS_PER_REQ = 750;
|
||||
|
||||
namespace monero {
|
||||
|
||||
/**
|
||||
* Polls daemon and sends notifications in order to notify external daemon listeners.
|
||||
*/
|
||||
class monero_daemon_poller : public gen_utils::thread_poller {
|
||||
public:
|
||||
|
||||
explicit monero_daemon_poller(monero_daemon* daemon, uint64_t poll_period_ms = 10000): m_daemon(daemon) {
|
||||
init_common("monero_daemon_rpc");
|
||||
m_poll_period_ms = poll_period_ms;
|
||||
}
|
||||
|
||||
~monero_daemon_poller() override {
|
||||
set_is_polling(false);
|
||||
}
|
||||
|
||||
void poll() override {
|
||||
if (!m_last_header) {
|
||||
m_last_header = m_daemon->get_last_block_header();
|
||||
return;
|
||||
}
|
||||
|
||||
auto header = m_daemon->get_last_block_header();
|
||||
if (header->m_hash != m_last_header->m_hash) {
|
||||
m_last_header = header;
|
||||
announce_block_header(header);
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
monero_daemon* m_daemon;
|
||||
std::shared_ptr<monero_block_header> m_last_header;
|
||||
|
||||
void announce_block_header(const std::shared_ptr<monero_block_header>& header) {
|
||||
gen_utils::thread_poller::announce_scope scope(*this); // see wait_for_callbacks_idle()
|
||||
auto listeners = m_daemon->get_listeners();
|
||||
for (auto& listener : listeners) {
|
||||
try {
|
||||
listener->on_block_header(header);
|
||||
} catch (const std::exception& e) {
|
||||
MERROR("Error calling listener on new block header: " << e.what());
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Sends a notification on a condition variable when a block is added to blockchain.
|
||||
*/
|
||||
class block_notifier : public monero_daemon_listener {
|
||||
public:
|
||||
block_notifier(boost::mutex* temp, boost::condition_variable* cv, bool* ready) { this->temp = temp; this->cv = cv; this->ready = ready; }
|
||||
|
||||
void on_block_header(const std::shared_ptr<monero_block_header>& header) override {
|
||||
boost::mutex::scoped_lock lock(*temp);
|
||||
m_last_header = header;
|
||||
*ready = true;
|
||||
cv->notify_one();
|
||||
}
|
||||
|
||||
private:
|
||||
boost::mutex* temp;
|
||||
boost::condition_variable* cv;
|
||||
bool* ready;
|
||||
};
|
||||
|
||||
void monero_daemon_rpc::set_poll_period_in_ms(uint64_t period_ms) {
|
||||
boost::lock_guard<boost::mutex> poller_lock(m_poller_mutex);
|
||||
if (!m_poller) m_poller = std::make_unique<monero_daemon_poller>(this);
|
||||
m_poller->set_period_in_ms(period_ms);
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate RPC response status.
|
||||
*/
|
||||
void check_response_status(const boost::property_tree::ptree& node) {
|
||||
for (boost::property_tree::ptree::const_iterator it = node.begin(); it != node.end(); ++it) {
|
||||
std::string key = it->first;
|
||||
if (key == std::string("status")) {
|
||||
std::string status = it->second.data();
|
||||
|
||||
// TODO monero-project empty string status is returned for download update response when an update is available
|
||||
if (status == std::string("OK") || status == std::string("")) {
|
||||
return;
|
||||
}
|
||||
else throw monero_rpc_error(status);
|
||||
}
|
||||
}
|
||||
|
||||
throw monero_error("Could not get JSON RPC response status");
|
||||
}
|
||||
|
||||
monero_daemon_rpc::monero_daemon_rpc(const std::shared_ptr<monero_rpc_connection>& rpc): m_rpc(rpc) {
|
||||
if (rpc == nullptr) throw monero_error("Connection cannot be null");
|
||||
if (!rpc->is_online().value_or(false) && rpc->m_uri != boost::none) rpc->check_connection();
|
||||
}
|
||||
|
||||
monero_daemon_rpc::monero_daemon_rpc(const std::string& uri, const std::string& username, const std::string& password, const std::string& proxy_uri, const std::string& zmq_uri, const boost::optional<uint32_t>& timeout):
|
||||
m_rpc(std::make_shared<monero_rpc_connection>(uri, username, password, proxy_uri, zmq_uri, 0, timeout)) {
|
||||
if (!uri.empty()) m_rpc->check_connection();
|
||||
}
|
||||
|
||||
std::set<monero_daemon_listener*> monero_daemon_rpc::get_listeners() {
|
||||
boost::lock_guard<boost::recursive_mutex> lock(m_listeners_mutex);
|
||||
return m_listeners;
|
||||
}
|
||||
|
||||
void monero_daemon_rpc::add_listener(monero_daemon_listener &listener) {
|
||||
{
|
||||
boost::lock_guard<boost::recursive_mutex> lock(m_listeners_mutex);
|
||||
m_listeners.insert(&listener);
|
||||
}
|
||||
refresh_listening();
|
||||
}
|
||||
|
||||
void monero_daemon_rpc::remove_listener(monero_daemon_listener &listener) {
|
||||
{
|
||||
boost::lock_guard<boost::recursive_mutex> lock(m_listeners_mutex);
|
||||
m_listeners.erase(&listener);
|
||||
}
|
||||
refresh_listening();
|
||||
wait_for_listener_callbacks_idle();
|
||||
}
|
||||
|
||||
void monero_daemon_rpc::remove_listeners() {
|
||||
{
|
||||
boost::lock_guard<boost::recursive_mutex> lock(m_listeners_mutex);
|
||||
m_listeners.clear();
|
||||
}
|
||||
refresh_listening();
|
||||
wait_for_listener_callbacks_idle();
|
||||
}
|
||||
|
||||
void monero_daemon_rpc::wait_for_listener_callbacks_idle() {
|
||||
// ensures no in-flight callback dispatch can still reference a just-removed listener
|
||||
monero_daemon_poller* poller;
|
||||
{
|
||||
boost::lock_guard<boost::mutex> poller_lock(m_poller_mutex);
|
||||
poller = m_poller.get();
|
||||
}
|
||||
if (poller != nullptr) poller->wait_for_callbacks_idle();
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_rpc_connection> monero_daemon_rpc::get_rpc_connection() const {
|
||||
MTRACE("monero_daemon_rpc::get_rpc_connection()");
|
||||
return m_rpc;
|
||||
}
|
||||
|
||||
bool monero_daemon_rpc::is_connected() {
|
||||
try {
|
||||
get_version();
|
||||
return true;
|
||||
}
|
||||
catch (...) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
monero_version monero_daemon_rpc::get_version() {
|
||||
auto result = m_rpc->send_json_request("get_version");
|
||||
check_response_status(result);
|
||||
monero_version version;
|
||||
deserialize_version(result, version);
|
||||
return version;
|
||||
}
|
||||
|
||||
bool monero_daemon_rpc::is_trusted() {
|
||||
auto result = m_rpc->send_path_request("get_height");
|
||||
check_response_status(result);
|
||||
auto get_height_response = std::make_shared<monero_get_block_result>();
|
||||
monero_get_block_result::from_property_tree(result, get_height_response);
|
||||
return gen_utils::bool_equals(false, get_height_response->m_untrusted);
|
||||
}
|
||||
|
||||
uint64_t monero_daemon_rpc::get_height() {
|
||||
auto result = m_rpc->send_json_request("get_block_count");
|
||||
check_response_status(result);
|
||||
std::shared_ptr<monero_get_block_result> block_result = std::make_shared<monero_get_block_result>();
|
||||
monero_get_block_result::from_property_tree(result, block_result);
|
||||
if (block_result->m_count == boost::none) throw monero_error("Could not get height");
|
||||
return block_result->m_count.get();
|
||||
}
|
||||
|
||||
std::string monero_daemon_rpc::get_block_hash(uint64_t height) {
|
||||
std::shared_ptr<monero_get_block_hash_params> params = std::make_shared<monero_get_block_hash_params>(height);
|
||||
auto result = m_rpc->send_json_request("on_get_block_hash", params);
|
||||
return result.data();
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_block_template> monero_daemon_rpc::get_block_template(const std::string& wallet_address, const boost::optional<int>& reserve_size) {
|
||||
MTRACE("monero_daemon_rpc::get_block_template()");
|
||||
auto params = std::make_shared<monero_get_block_params>(wallet_address, reserve_size);
|
||||
auto result = m_rpc->send_json_request("get_block_template", params);
|
||||
check_response_status(result);
|
||||
std::shared_ptr<monero_block_template> tmplt = std::make_shared<monero_block_template>();
|
||||
deserialize_block_template(result, tmplt);
|
||||
return tmplt;
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_block_header> monero_daemon_rpc::get_last_block_header() {
|
||||
auto result = m_rpc->send_json_request("get_last_block_header");
|
||||
check_response_status(result);
|
||||
std::shared_ptr<monero_block_header> header = std::make_shared<monero_block_header>();
|
||||
deserialize_block_header(result, header);
|
||||
return header;
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_block_header> monero_daemon_rpc::get_block_header_by_hash(const std::string& hash) {
|
||||
std::shared_ptr<monero_get_block_params> params = std::make_shared<monero_get_block_params>(hash);
|
||||
auto result = m_rpc->send_json_request("get_block_header_by_hash", params);
|
||||
check_response_status(result);
|
||||
std::shared_ptr<monero_block_header> header = std::make_shared<monero_block_header>();
|
||||
deserialize_block_header(result, header);
|
||||
return header;
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_block_header> monero_daemon_rpc::get_block_header_by_height(uint64_t height) {
|
||||
std::shared_ptr<monero_get_block_params> params = std::make_shared<monero_get_block_params>(height);
|
||||
auto result = m_rpc->send_json_request("get_block_header_by_height", params);
|
||||
check_response_status(result);
|
||||
std::shared_ptr<monero_block_header> header = std::make_shared<monero_block_header>();
|
||||
deserialize_block_header(result, header);
|
||||
return header;
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<monero_block_header>> monero_daemon_rpc::get_block_headers_by_range(uint64_t start_height, uint64_t end_height) {
|
||||
auto params = std::make_shared<monero_get_block_params>(start_height, end_height);
|
||||
auto result = m_rpc->send_json_request("get_block_headers_range", params);
|
||||
check_response_status(result);
|
||||
std::vector<std::shared_ptr<monero_block_header>> headers;
|
||||
deserialize_block_headers(result, headers);
|
||||
return headers;
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_block> monero_daemon_rpc::get_block_by_hash(const std::string& hash) {
|
||||
std::shared_ptr<monero_get_block_params> params = std::make_shared<monero_get_block_params>(hash);
|
||||
auto result = m_rpc->send_json_request("get_block", params);
|
||||
check_response_status(result);
|
||||
auto block = std::make_shared<monero_block>();
|
||||
deserialize_block(result, block);
|
||||
return block;
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_block_header> monero_daemon_rpc::get_block_header_by_height_cached(uint64_t height, uint64_t max_height, std::unordered_map<uint64_t, std::shared_ptr<monero_block_header>>& header_cache) {
|
||||
// get header from cache
|
||||
auto found = header_cache.find(height);
|
||||
if (found != header_cache.end()) return found->second;
|
||||
|
||||
// fetch and cache headers if not in cache
|
||||
uint64_t end_height = std::min(max_height, height + NUM_HEADERS_PER_REQ - 1);
|
||||
auto headers = get_block_headers_by_range(height, end_height);
|
||||
|
||||
for(const auto& header : headers) {
|
||||
if (header->m_height == boost::none) throw monero_error("Malformed block header: expected height to be defined");
|
||||
header_cache[header->m_height.get()] = header;
|
||||
}
|
||||
|
||||
// look up rather than default-construct via operator[]: a daemon response missing the
|
||||
// requested height must not silently cache (and return) a null header
|
||||
found = header_cache.find(height);
|
||||
if (found == header_cache.end()) throw monero_error("Daemon did not return a header for height " + std::to_string(height));
|
||||
return found->second;
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<monero_block>> monero_daemon_rpc::get_blocks_by_hash(const std::vector<std::string>& block_hashes, uint64_t start_height, bool prune) {
|
||||
throw monero_error("monero_daemon_rpc::get_blocks_by_hash(): not implemented");
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_block> monero_daemon_rpc::get_block_by_height(uint64_t height) {
|
||||
std::shared_ptr<monero_get_block_params> params = std::make_shared<monero_get_block_params>(height);
|
||||
auto result = m_rpc->send_json_request("get_block", params);
|
||||
check_response_status(result);
|
||||
auto block = std::make_shared<monero_block>();
|
||||
deserialize_block(result, block);
|
||||
return block;
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<monero_block>> monero_daemon_rpc::get_blocks_by_height(const std::vector<uint64_t>& heights) {
|
||||
// fetch blocks in binary
|
||||
monero_get_blocks_by_height_request request(heights);
|
||||
auto response = m_rpc->send_binary_request(request);
|
||||
if (response.m_binary == boost::none) throw monero_error("Invalid Monero Binary response");
|
||||
boost::property_tree::ptree node;
|
||||
monero_utils::binary_blocks_to_property_tree(response.m_binary.get(), node);
|
||||
check_response_status(node);
|
||||
std::vector<std::shared_ptr<monero_block>> blocks;
|
||||
deserialize_blocks(node, heights, blocks);
|
||||
return blocks;
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<monero_block>> monero_daemon_rpc::get_blocks_by_range(boost::optional<uint64_t> start_height, boost::optional<uint64_t> end_height) {
|
||||
if (start_height == boost::none) start_height = 0;
|
||||
if (end_height == boost::none) {
|
||||
uint64_t block_height = get_height();
|
||||
end_height = block_height == 0 ? 0 : block_height - 1;
|
||||
}
|
||||
|
||||
std::vector<uint64_t> heights;
|
||||
for (uint64_t height = start_height.get(); height <= end_height.get(); height++) heights.push_back(height);
|
||||
|
||||
return get_blocks_by_height(heights);
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<monero_block>> monero_daemon_rpc::get_blocks_by_range_chunked(boost::optional<uint64_t> start_height, boost::optional<uint64_t> end_height, boost::optional<uint64_t> max_chunk_size) {
|
||||
if (start_height == boost::none) start_height = 0;
|
||||
if (end_height == boost::none) {
|
||||
uint64_t block_height = get_height();
|
||||
end_height = block_height == 0 ? 0 : block_height - 1;
|
||||
}
|
||||
|
||||
boost::optional<uint64_t> last_height = boost::none;
|
||||
std::vector<std::shared_ptr<monero_block>> blocks;
|
||||
|
||||
if (start_height.get() > end_height.get()) return blocks;
|
||||
|
||||
// scoped to this call: see the comment on get_max_blocks()/get_block_header_by_height_cached() in the header
|
||||
std::unordered_map<uint64_t, std::shared_ptr<monero_block_header>> header_cache;
|
||||
|
||||
while (last_height == boost::none || last_height.get() < end_height.get()) {
|
||||
uint64_t height_to_get = (last_height == boost::none) ? start_height.get() : last_height.get() + 1;
|
||||
|
||||
auto max_blocks = get_max_blocks(height_to_get, end_height, max_chunk_size, header_cache);
|
||||
if (max_blocks.empty()) throw monero_error("Daemon returned an empty block chunk for a non-empty range at height " + std::to_string(height_to_get));
|
||||
blocks.insert(blocks.end(), max_blocks.begin(), max_blocks.end());
|
||||
last_height = blocks[blocks.size() - 1]->m_height.get();
|
||||
}
|
||||
|
||||
return blocks;
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<monero_block>> monero_daemon_rpc::get_max_blocks(boost::optional<uint64_t> start_height, boost::optional<uint64_t> max_height, boost::optional<uint64_t> chunk_size, std::unordered_map<uint64_t, std::shared_ptr<monero_block_header>>& header_cache) {
|
||||
if (start_height == boost::none) start_height = 0;
|
||||
if (max_height == boost::none) {
|
||||
uint64_t block_height = get_height();
|
||||
max_height = block_height == 0 ? 0 : block_height - 1;
|
||||
}
|
||||
if (chunk_size == boost::none) chunk_size = MAX_REQ_SIZE;
|
||||
|
||||
// determine end height to fetch
|
||||
uint64_t req_size = 0;
|
||||
boost::optional<uint64_t> end_height = boost::none; // none = no block accepted yet
|
||||
uint64_t height_to_get = start_height.get();
|
||||
|
||||
while (req_size < chunk_size.get() && height_to_get <= max_height.get()) {
|
||||
// get header of next block
|
||||
auto header = get_block_header_by_height_cached(height_to_get, max_height.get(), header_cache);
|
||||
if (header->m_size == boost::none) throw monero_error("Malformed block header: expected size to be defined");
|
||||
uint64_t header_size = header->m_size.get();
|
||||
// block cannot be bigger than max request size
|
||||
if (header_size > chunk_size.get()) throw monero_error("Block exceeds maximum request size: " + std::to_string(header_size));
|
||||
|
||||
// done iterating if fetching block would exceed max request size
|
||||
if (req_size + header_size > chunk_size.get()) break;
|
||||
|
||||
// otherwise block is included
|
||||
req_size += header_size;
|
||||
end_height = height_to_get;
|
||||
height_to_get++;
|
||||
}
|
||||
|
||||
if (end_height != boost::none) {
|
||||
return get_blocks_by_range(start_height, end_height.get());
|
||||
}
|
||||
|
||||
return std::vector<std::shared_ptr<monero_block>>();
|
||||
}
|
||||
|
||||
std::vector<std::string> monero_daemon_rpc::get_block_hashes(const std::vector<std::string>& block_hashes, uint64_t start_height) {
|
||||
throw monero_error("monero_daemon_rpc::get_block_hashes(): not implemented");
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<monero_tx>> monero_daemon_rpc::get_txs(const std::vector<std::string>& tx_hashes, bool prune) {
|
||||
MTRACE("monero_daemon_rpc::get_txs()");
|
||||
if (tx_hashes.empty()) throw monero_error("Must provide an array of transaction hashes");
|
||||
auto params = std::make_shared<monero_get_txs_params>(tx_hashes, prune);
|
||||
auto result = m_rpc->send_path_request("get_transactions", params);
|
||||
|
||||
try { check_response_status(result); }
|
||||
catch (const std::exception& ex) {
|
||||
if (std::string(ex.what()).find("Failed to parse hex representation of transaction hash") != std::string::npos) {
|
||||
throw monero_error("Invalid transaction hash");
|
||||
}
|
||||
throw;
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<monero_tx>> txs;
|
||||
deserialize_txs(result, txs);
|
||||
return txs;
|
||||
}
|
||||
|
||||
std::vector<std::string> monero_daemon_rpc::get_tx_hexes(const std::vector<std::string>& tx_hashes, bool prune) {
|
||||
MTRACE("monero_daemon_rpc::get_tx_hexes()");
|
||||
std::vector<std::string> hexes;
|
||||
for(const auto& tx : get_txs(tx_hashes, prune)) {
|
||||
// tx may be pruned regardless of configuration
|
||||
if (tx->m_pruned_hex == boost::none) {
|
||||
if (tx->m_full_hex == boost::none) throw monero_error("Tx has no hex");
|
||||
hexes.push_back(tx->m_full_hex.get());
|
||||
} else {
|
||||
hexes.push_back(tx->m_pruned_hex.get());
|
||||
}
|
||||
}
|
||||
return hexes;
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_miner_tx_sum> monero_daemon_rpc::get_miner_tx_sum(uint64_t height, uint64_t num_blocks) {
|
||||
auto params = std::make_shared<monero_get_miner_tx_sum_params>(height, num_blocks);
|
||||
auto result = m_rpc->send_json_request("get_coinbase_tx_sum", params);
|
||||
check_response_status(result);
|
||||
auto sum = std::make_shared<monero_miner_tx_sum>();
|
||||
deserialize_miner_tx_sum(result, sum);
|
||||
return sum;
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_fee_estimate> monero_daemon_rpc::get_fee_estimate(uint64_t grace_blocks) {
|
||||
auto params = std::make_shared<monero_get_fee_estimate_params>(grace_blocks);
|
||||
auto result = m_rpc->send_json_request("get_fee_estimate", params);
|
||||
check_response_status(result);
|
||||
auto estimate = std::make_shared<monero_fee_estimate>();
|
||||
deserialize_fee_estimate(result, estimate);
|
||||
return estimate;
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_submit_tx_result> monero_daemon_rpc::submit_tx_hex(const std::string& tx_hex, bool do_not_relay) {
|
||||
MTRACE("monero_daemon_rpc::submit_tx_hex()");
|
||||
auto params = std::make_shared<monero_submit_tx_params>(tx_hex, do_not_relay);
|
||||
auto result = m_rpc->send_path_request("send_raw_transaction", params);
|
||||
auto sum = std::make_shared<monero_submit_tx_result>();
|
||||
deserialize_submit_tx_result(result, sum);
|
||||
|
||||
// set m_is_good based on status
|
||||
try {
|
||||
check_response_status(result);
|
||||
sum->m_is_good = true;
|
||||
} catch (...) {
|
||||
sum->m_is_good = false;
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
void monero_daemon_rpc::relay_txs_by_hash(const std::vector<std::string>& tx_hashes) {
|
||||
MTRACE("monero_daemon_rpc::relay_txs_by_hash()");
|
||||
auto params = std::make_shared<monero_submit_tx_params>(tx_hashes);
|
||||
auto result = m_rpc->send_json_request("relay_tx", params);
|
||||
check_response_status(result);
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_tx_pool_stats> monero_daemon_rpc::get_tx_pool_stats() {
|
||||
auto result = m_rpc->send_path_request("get_transaction_pool_stats");
|
||||
check_response_status(result);
|
||||
auto stats = std::make_shared<monero_tx_pool_stats>();
|
||||
deserialize_tx_pool_stats(result, stats);
|
||||
return stats;
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<monero_tx>> monero_daemon_rpc::get_tx_pool() {
|
||||
auto result = m_rpc->send_path_request("get_transaction_pool");
|
||||
check_response_status(result);
|
||||
std::vector<std::shared_ptr<monero_tx>> pool;
|
||||
deserialize_txs(result, pool);
|
||||
return pool;
|
||||
}
|
||||
|
||||
std::vector<std::string> monero_daemon_rpc::get_tx_pool_hashes() {
|
||||
auto result = m_rpc->send_path_request("get_transaction_pool_hashes");
|
||||
check_response_status(result);
|
||||
std::vector<std::string> tx_hashes;
|
||||
deserialize_tx_hashes(result, tx_hashes);
|
||||
return tx_hashes;
|
||||
}
|
||||
|
||||
void monero_daemon_rpc::flush_tx_pool(const std::vector<std::string> &hashes) {
|
||||
MTRACE("monero_daemon_rpc::flush_tx_pool()");
|
||||
auto params = std::make_shared<monero_submit_tx_params>(hashes);
|
||||
auto result = m_rpc->send_json_request("flush_txpool", params);
|
||||
check_response_status(result);
|
||||
}
|
||||
|
||||
void monero_daemon_rpc::flush_tx_pool() {
|
||||
std::vector<std::string> hashes;
|
||||
flush_tx_pool(hashes);
|
||||
}
|
||||
|
||||
void monero_daemon_rpc::flush_tx_pool(const std::string &hash) {
|
||||
std::vector<std::string> hashes;
|
||||
hashes.push_back(hash);
|
||||
flush_tx_pool(hashes);
|
||||
}
|
||||
|
||||
std::vector<monero_key_image_spent_status> monero_daemon_rpc::get_key_image_spent_statuses(const std::vector<std::string>& key_images) {
|
||||
if (key_images.empty()) throw monero_error("Must provide key images to check the status of");
|
||||
auto params = std::make_shared<monero_is_key_image_spent_params>(key_images);
|
||||
auto result = m_rpc->send_path_request("is_key_image_spent", params);
|
||||
check_response_status(result);
|
||||
std::vector<monero_key_image_spent_status> statuses;
|
||||
deserialize_key_image_spent_status(result, statuses);
|
||||
return statuses;
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<monero_output>> monero_daemon_rpc::get_outputs(const std::vector<monero_output>& outputs) {
|
||||
throw monero_error("monero_daemon_rpc::get_outputs(): not implemented");
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<monero_output_histogram_entry>> monero_daemon_rpc::get_output_histogram(const std::vector<uint64_t>& amounts, const boost::optional<int>& min_count, const boost::optional<int>& max_count, const boost::optional<bool>& is_unlocked, const boost::optional<int>& recent_cutoff) {
|
||||
MTRACE("monero_daemon_rpc::get_output_histogram()");
|
||||
auto params = std::make_shared<monero_get_output_histogram_params>(amounts, min_count, max_count, is_unlocked, recent_cutoff);
|
||||
auto result = m_rpc->send_json_request("get_output_histogram", params);
|
||||
check_response_status(result);
|
||||
std::vector<std::shared_ptr<monero_output_histogram_entry>> entries;
|
||||
deserialize_output_histogram_entries(result, entries);
|
||||
return entries;
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<monero_output_distribution_entry>> monero_daemon_rpc::get_output_distribution(const std::vector<uint64_t>& amounts, const boost::optional<bool>& is_cumulative, const boost::optional<uint64_t>& start_height, const boost::optional<uint64_t>& end_height) {
|
||||
MTRACE("monero_daemon_rpc::get_output_distribution()");
|
||||
auto params = std::make_shared<monero_get_output_distribution_params>(amounts, is_cumulative, start_height, end_height);
|
||||
auto result = m_rpc->send_json_request("get_output_distribution", params);
|
||||
check_response_status(result);
|
||||
std::vector<std::shared_ptr<monero_output_distribution_entry>> entries;
|
||||
deserialize_output_distribution_entries(result, entries);
|
||||
return entries;
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_daemon_info> monero_daemon_rpc::get_info() {
|
||||
auto result = m_rpc->send_json_request("get_info");
|
||||
check_response_status(result);
|
||||
std::shared_ptr<monero_daemon_info> info = std::make_shared<monero_daemon_info>();
|
||||
deserialize_daemon_info(result, info);
|
||||
return info;
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_daemon_sync_info> monero_daemon_rpc::get_sync_info() {
|
||||
auto result = m_rpc->send_json_request("sync_info");
|
||||
check_response_status(result);
|
||||
std::shared_ptr<monero_daemon_sync_info> info = std::make_shared<monero_daemon_sync_info>();
|
||||
deserialize_daemon_sync_info(result, info);
|
||||
return info;
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_hard_fork_info> monero_daemon_rpc::get_hard_fork_info() {
|
||||
auto result = m_rpc->send_json_request("hard_fork_info");
|
||||
check_response_status(result);
|
||||
std::shared_ptr<monero_hard_fork_info> info = std::make_shared<monero_hard_fork_info>();
|
||||
deserialize_hard_fork_info(result, info);
|
||||
return info;
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<monero_alt_chain>> monero_daemon_rpc::get_alt_chains() {
|
||||
auto result = m_rpc->send_json_request("get_alternate_chains");
|
||||
check_response_status(result);
|
||||
std::vector<std::shared_ptr<monero_alt_chain>> alt_chains;
|
||||
deserialize_alt_chains(result, alt_chains);
|
||||
return alt_chains;
|
||||
}
|
||||
|
||||
std::vector<std::string> monero_daemon_rpc::get_alt_block_hashes() {
|
||||
auto result = m_rpc->send_path_request("get_alt_blocks_hashes");
|
||||
check_response_status(result);
|
||||
std::vector<std::string> hashes;
|
||||
deserialize_alt_block_hashes(result, hashes);
|
||||
return hashes;
|
||||
}
|
||||
|
||||
int monero_daemon_rpc::get_download_limit() {
|
||||
MTRACE("monero_daemon_rpc::get_download_limit()");
|
||||
auto limits = get_bandwidth_limits();
|
||||
if (limits->m_down != boost::none) return limits->m_down.get();
|
||||
throw monero_error("Could not get download limit");
|
||||
}
|
||||
|
||||
int monero_daemon_rpc::set_download_limit(int limit) {
|
||||
MTRACE("monero_daemon_rpc::set_download_limit()");
|
||||
if (limit == -1) return reset_download_limit();
|
||||
if (limit <= 0) throw monero_error("Download limit must be an integer greater than 0");
|
||||
auto result = set_bandwidth_limits(0, limit);
|
||||
if (result->m_down != boost::none) return result->m_down.get();
|
||||
throw monero_error("Could not set download limit");
|
||||
}
|
||||
|
||||
int monero_daemon_rpc::reset_download_limit() {
|
||||
MTRACE("monero_daemon_rpc::reset_download_limit()");
|
||||
auto result = set_bandwidth_limits(0, -1);
|
||||
if (result->m_down != boost::none) return result->m_down.get();
|
||||
throw monero_error("Could not set download limit");
|
||||
}
|
||||
|
||||
int monero_daemon_rpc::get_upload_limit() {
|
||||
MTRACE("monero_daemon_rpc::get_upload_limit()");
|
||||
auto limits = get_bandwidth_limits();
|
||||
if (limits->m_up != boost::none) return limits->m_up.get();
|
||||
throw monero_error("Could not get upload limit");
|
||||
}
|
||||
|
||||
int monero_daemon_rpc::set_upload_limit(int limit) {
|
||||
MTRACE("monero_daemon_rpc::set_upload_limit()");
|
||||
if (limit == -1) return reset_upload_limit();
|
||||
if (limit <= 0) throw monero_error("Upload limit must be an integer greater than 0");
|
||||
auto result = set_bandwidth_limits(limit, 0);
|
||||
if (result->m_up != boost::none) return result->m_up.get();
|
||||
throw monero_error("Could not set download limit");
|
||||
}
|
||||
|
||||
int monero_daemon_rpc::reset_upload_limit() {
|
||||
MTRACE("monero_daemon_rpc::reset_upload_limit()");
|
||||
auto result = set_bandwidth_limits(-1, 0);
|
||||
if (result->m_up != boost::none) return result->m_up.get();
|
||||
throw monero_error("Could not set download limit");
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<monero_peer>> monero_daemon_rpc::get_peers() {
|
||||
auto result = m_rpc->send_json_request("get_connections");
|
||||
check_response_status(result);
|
||||
std::vector<std::shared_ptr<monero_peer>> peers;
|
||||
deserialize_peers(result, peers);
|
||||
return peers;
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<monero_peer>> monero_daemon_rpc::get_known_peers() {
|
||||
auto result = m_rpc->send_path_request("get_peer_list");
|
||||
check_response_status(result);
|
||||
std::vector<std::shared_ptr<monero_peer>> peers;
|
||||
deserialize_peers(result, peers);
|
||||
return peers;
|
||||
}
|
||||
|
||||
void monero_daemon_rpc::set_outgoing_peer_limit(int limit) {
|
||||
MTRACE("monero_daemon_rpc::set_outgoing_peer_limit()");
|
||||
if (limit < 0) throw monero_error("Outgoing peer limit must be >= 0");
|
||||
auto params = std::make_shared<monero_peer_limits_params>();
|
||||
params->m_out_peers = limit;
|
||||
auto result = m_rpc->send_path_request("out_peers", params);
|
||||
check_response_status(result);
|
||||
}
|
||||
|
||||
void monero_daemon_rpc::set_incoming_peer_limit(int limit) {
|
||||
MTRACE("monero_daemon_rpc::set_incoming_peer_limit()");
|
||||
if (limit < 0) throw monero_error("Incoming peer limit must be >= 0");
|
||||
auto params = std::make_shared<monero_peer_limits_params>();
|
||||
params->m_in_peers = limit;
|
||||
auto result = m_rpc->send_path_request("in_peers", params);
|
||||
check_response_status(result);
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<monero_ban>> monero_daemon_rpc::get_peer_bans() {
|
||||
MTRACE("monero_daemon_rpc::get_peer_bans()");
|
||||
auto result = m_rpc->send_json_request("get_bans");
|
||||
check_response_status(result);
|
||||
std::vector<std::shared_ptr<monero_ban>> bans;
|
||||
deserialize_bans(result, bans);
|
||||
return bans;
|
||||
}
|
||||
|
||||
void monero_daemon_rpc::set_peer_bans(const std::vector<std::shared_ptr<monero_ban>>& bans) {
|
||||
MTRACE("monero_daemon_rpc::set_peer_bans()");
|
||||
auto params = std::make_shared<monero_set_bans_params>(bans);
|
||||
auto result = m_rpc->send_json_request("set_bans", params);
|
||||
check_response_status(result);
|
||||
}
|
||||
|
||||
void monero_daemon_rpc::start_mining(const std::string &address, boost::optional<uint64_t> num_threads, boost::optional<bool> background_mining, boost::optional<bool> ignore_battery) {
|
||||
MTRACE("monero_daemon_rpc::start_mining()");
|
||||
if (address.empty()) throw monero_error("Must provide address to mine to");
|
||||
if (num_threads != boost::none && num_threads.get() == 0) throw monero_error("Number of threads must be an integer greater than 0");
|
||||
auto params = std::make_shared<monero_start_mining_params>(address, num_threads, background_mining, ignore_battery);
|
||||
auto result = m_rpc->send_path_request("start_mining", params);
|
||||
check_response_status(result);
|
||||
}
|
||||
|
||||
void monero_daemon_rpc::stop_mining() {
|
||||
MTRACE("monero_daemon_rpc::stop_mining()");
|
||||
auto result = m_rpc->send_path_request("stop_mining");
|
||||
check_response_status(result);
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_mining_status> monero_daemon_rpc::get_mining_status() {
|
||||
MTRACE("monero_daemon_rpc::get_mining_status()");
|
||||
auto result = m_rpc->send_path_request("mining_status");
|
||||
check_response_status(result);
|
||||
auto status = std::make_shared<monero_mining_status>();
|
||||
deserialize_mining_status(result, status);
|
||||
return status;
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_generate_blocks_result> monero_daemon_rpc::generate_blocks(const std::string& wallet_address, uint64_t num_blocks, const boost::optional<std::string>& prev_block_hash, const boost::optional<uint32_t>& starting_nonce) {
|
||||
MTRACE("monero_daemon_rpc::generate_blocks()");
|
||||
if (wallet_address.empty()) throw monero_error("Must provide an address to mine to");
|
||||
if (num_blocks == 0) throw monero_error("Must provide a number of blocks to generate greater than 0");
|
||||
auto params = std::make_shared<monero_generate_blocks_params>(wallet_address, num_blocks, prev_block_hash, starting_nonce);
|
||||
auto result = m_rpc->send_json_request("generateblocks", params);
|
||||
check_response_status(result);
|
||||
auto generate_result = std::make_shared<monero_generate_blocks_result>();
|
||||
deserialize_generate_blocks_result(result, generate_result);
|
||||
return generate_result;
|
||||
}
|
||||
|
||||
void monero_daemon_rpc::submit_blocks(const std::vector<std::string>& block_blobs) {
|
||||
MTRACE("monero_daemon_rpc::submit_blocks()");
|
||||
if (block_blobs.empty()) throw monero_error("Must provide an array of mined block blobs to submit");
|
||||
auto params = std::make_shared<monero_submit_blocks_params>(block_blobs);
|
||||
auto result = m_rpc->send_json_request("submit_block", params);
|
||||
check_response_status(result);
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_prune_result> monero_daemon_rpc::prune_blockchain(bool check) {
|
||||
MTRACE("monero_daemon_rpc::prune_blockchain()");
|
||||
auto params = std::make_shared<monero_prune_blockchain_params>(check);
|
||||
auto result = m_rpc->send_json_request("prune_blockchain", params);
|
||||
check_response_status(result);
|
||||
std::shared_ptr<monero_prune_result> prune_result = std::make_shared<monero_prune_result>();
|
||||
deserialize_prune_result(result, prune_result);
|
||||
return prune_result;
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_daemon_update_check_result> monero_daemon_rpc::check_for_update() {
|
||||
MTRACE("monero_daemon_rpc::check_for_update()");
|
||||
auto params = std::make_shared<monero_download_update_params>("check");
|
||||
auto result = m_rpc->send_path_request("update", params);
|
||||
check_response_status(result);
|
||||
auto check_result = std::make_shared<monero_daemon_update_check_result>();
|
||||
deserialize_update_check_result(result, check_result);
|
||||
return check_result;
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_daemon_update_download_result> monero_daemon_rpc::download_update(const std::string& path) {
|
||||
MTRACE("monero_daemon_rpc::download_update()");
|
||||
auto params = std::make_shared<monero_download_update_params>("download", path);
|
||||
auto result = m_rpc->send_path_request("update", params);
|
||||
check_response_status(result);
|
||||
auto download_result = std::make_shared<monero_daemon_update_download_result>();
|
||||
deserialize_update_download_result(result, download_result);
|
||||
return download_result;
|
||||
}
|
||||
|
||||
void monero_daemon_rpc::stop() {
|
||||
MTRACE("monero_daemon_rpc::stop()");
|
||||
auto result = m_rpc->send_path_request("stop_daemon");
|
||||
check_response_status(result);
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_block_header> monero_daemon_rpc::wait_for_next_block_header() {
|
||||
MTRACE("monero_daemon_rpc::wait_for_next_block_header()");
|
||||
|
||||
// use mutex and condition variable with predicate to wait for block
|
||||
boost::mutex temp;
|
||||
boost::condition_variable cv;
|
||||
bool ready = false;
|
||||
|
||||
// create listener which notifies condition variable when block is added
|
||||
block_notifier block_listener(&temp, &cv, &ready);
|
||||
|
||||
// register the listener, and unregister it unconditionally on the way out
|
||||
// otherwise m_listeners keeps a pointer into this stack
|
||||
// frame after it's gone, and the next block dispatch calls through it (UAF)
|
||||
struct listener_guard {
|
||||
monero_daemon_rpc* daemon;
|
||||
monero_daemon_listener& listener;
|
||||
~listener_guard() {
|
||||
// never let remove_listener() escape a destructor since if we're
|
||||
// already unwinding from another exception, that would call std::terminate
|
||||
try { daemon->remove_listener(listener); } catch (...) {}
|
||||
}
|
||||
} unregister_guard{this, block_listener};
|
||||
|
||||
add_listener(block_listener);
|
||||
|
||||
// guard against an offline/unresponsive daemon (no connection, stalled node, etc.):
|
||||
// such a daemon will never announce a new block, so bound the wait instead of hanging
|
||||
// this call forever.
|
||||
// TODO monero-java waits indefinitely.
|
||||
bool timed_out;
|
||||
std::shared_ptr<monero_block_header> header;
|
||||
{
|
||||
boost::mutex::scoped_lock lock(temp);
|
||||
cv.timed_wait(lock, boost::posix_time::minutes(30), [&]() { return ready; });
|
||||
// check ready directly rather than trust timed_wait's return value, still under the
|
||||
// lock: avoids any discrepancy if a header arrives right at the timeout boundary
|
||||
timed_out = !ready;
|
||||
// copy out while still holding the lock: block_listener stays registered until the
|
||||
// unregister_guard destructor runs (at function exit, after this point), so
|
||||
// on_block_header() could still write m_last_header under temp concurrently with an
|
||||
// unlocked read here
|
||||
if (!timed_out) header = block_listener.m_last_header;
|
||||
}
|
||||
|
||||
if (timed_out) throw monero_error("Timed out waiting for next block header");
|
||||
|
||||
// return last height
|
||||
if (header == nullptr) throw monero_error("Could not get last block header.");
|
||||
return header;
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_bandwidth_limits> monero_daemon_rpc::get_bandwidth_limits() {
|
||||
MTRACE("monero_daemon_rpc::get_bandwidth_limits()");
|
||||
auto result = m_rpc->send_path_request("get_limit");
|
||||
check_response_status(result);
|
||||
auto limits = std::make_shared<monero_bandwidth_limits>();
|
||||
monero_bandwidth_limits::from_property_tree(result, limits);
|
||||
return limits;
|
||||
}
|
||||
|
||||
std::shared_ptr<monero_bandwidth_limits> monero_daemon_rpc::set_bandwidth_limits(int up, int down) {
|
||||
MTRACE("monero_daemon_rpc::set_bandwidth_limits()");
|
||||
auto limits = std::make_shared<monero_bandwidth_limits>(up, down);
|
||||
auto result = m_rpc->send_path_request("set_limit", limits);
|
||||
check_response_status(result);
|
||||
monero_bandwidth_limits::from_property_tree(result, limits);
|
||||
return limits;
|
||||
}
|
||||
|
||||
void monero_daemon_rpc::refresh_listening() {
|
||||
boost::lock_guard<boost::mutex> poller_lock(m_poller_mutex);
|
||||
|
||||
bool should_poll;
|
||||
{
|
||||
boost::lock_guard<boost::recursive_mutex> lock(m_listeners_mutex);
|
||||
should_poll = m_listeners.size() > 0;
|
||||
}
|
||||
|
||||
if (!m_poller && should_poll) {
|
||||
m_poller = std::make_unique<monero_daemon_poller>(this);
|
||||
}
|
||||
if (m_poller) m_poller->request_is_polling(should_poll);
|
||||
}
|
||||
|
||||
monero_daemon_rpc::~monero_daemon_rpc() {
|
||||
MTRACE("~monero_daemon_rpc()");
|
||||
remove_listeners();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,189 @@
|
||||
/**
|
||||
* Copyright (c) everoddandeven
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*
|
||||
* Parts of this file are originally copyright (c) 2025-2026 woodser
|
||||
*
|
||||
* Parts of this file are originally copyright (c) 2014-2019, The Monero Project
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification, are
|
||||
* permitted provided that the following conditions are met:
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
* 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 "monero_daemon.h"
|
||||
|
||||
/**
|
||||
* Implements a monero_daemon.h using monero-project's monerod.
|
||||
*/
|
||||
namespace monero {
|
||||
|
||||
// forward declaration of internal daemon poller
|
||||
class monero_daemon_poller;
|
||||
|
||||
/**
|
||||
* Implements a Monero daemon using monerod-rpc.
|
||||
*/
|
||||
class monero_daemon_rpc : public monero_daemon {
|
||||
public:
|
||||
|
||||
/**
|
||||
* Destruct the daemon.
|
||||
*/
|
||||
~monero_daemon_rpc() override;
|
||||
monero_daemon_rpc(const std::shared_ptr<monero_rpc_connection>& rpc);
|
||||
monero_daemon_rpc(const std::string& uri, const std::string& username = "", const std::string& password = "", const std::string& proxy_uri = "", const std::string& zmq_uri = "", const boost::optional<uint32_t>& timeout = boost::none);
|
||||
|
||||
/**
|
||||
* Get the daemon's RPC connection.
|
||||
*
|
||||
* @return the daemon's rpc connection
|
||||
*/
|
||||
std::shared_ptr<monero_rpc_connection> get_rpc_connection() const;
|
||||
|
||||
/**
|
||||
* Indicates if the client is connected to the daemon via RPC.
|
||||
*
|
||||
* @return true if the client is connected to the daemon, false otherwise
|
||||
*/
|
||||
bool is_connected();
|
||||
|
||||
/**
|
||||
* Set the daemon poll period.
|
||||
*
|
||||
* @param period_ms poll period in milliseconds.
|
||||
*/
|
||||
void set_poll_period_in_ms(uint64_t period_ms);
|
||||
|
||||
/**
|
||||
* Supported daemon methods.
|
||||
*/
|
||||
std::set<monero_daemon_listener*> get_listeners() override;
|
||||
void add_listener(monero_daemon_listener &listener) override;
|
||||
void remove_listener(monero_daemon_listener &listener) override;
|
||||
void remove_listeners() override;
|
||||
monero_version get_version() override;
|
||||
bool is_trusted() override;
|
||||
uint64_t get_height() override;
|
||||
std::string get_block_hash(uint64_t height) override;
|
||||
std::shared_ptr<monero_block_template> get_block_template(const std::string& wallet_address, const boost::optional<int>& reserve_size = boost::none) override;
|
||||
std::shared_ptr<monero_block_header> get_last_block_header() override;
|
||||
std::shared_ptr<monero_block_header> get_block_header_by_hash(const std::string& hash) override;
|
||||
std::shared_ptr<monero_block_header> get_block_header_by_height(uint64_t height) override;
|
||||
std::vector<std::shared_ptr<monero_block_header>> get_block_headers_by_range(uint64_t start_height, uint64_t end_height) override;
|
||||
std::shared_ptr<monero_block> get_block_by_hash(const std::string& hash) override;
|
||||
std::vector<std::shared_ptr<monero_block>> get_blocks_by_hash(const std::vector<std::string>& block_hashes, uint64_t start_height, bool prune) override;
|
||||
std::shared_ptr<monero_block> get_block_by_height(uint64_t height) override;
|
||||
std::vector<std::shared_ptr<monero_block>> get_blocks_by_height(const std::vector<uint64_t>& heights) override;
|
||||
std::vector<std::shared_ptr<monero_block>> get_blocks_by_range(boost::optional<uint64_t> start_height, boost::optional<uint64_t> end_height) override;
|
||||
std::vector<std::shared_ptr<monero_block>> get_blocks_by_range_chunked(boost::optional<uint64_t> start_height, boost::optional<uint64_t> end_height, boost::optional<uint64_t> max_chunk_size) override;
|
||||
std::vector<std::string> get_block_hashes(const std::vector<std::string>& block_hashes, uint64_t start_height) override;
|
||||
std::vector<std::shared_ptr<monero_tx>> get_txs(const std::vector<std::string>& tx_hashes, bool prune = false) override;
|
||||
std::vector<std::string> get_tx_hexes(const std::vector<std::string>& tx_hashes, bool prune = false) override;
|
||||
std::shared_ptr<monero_miner_tx_sum> get_miner_tx_sum(uint64_t height, uint64_t num_blocks) override;
|
||||
std::shared_ptr<monero_fee_estimate> get_fee_estimate(uint64_t grace_blocks = 0) override;
|
||||
std::shared_ptr<monero_submit_tx_result> submit_tx_hex(const std::string& tx_hex, bool do_not_relay = false) override;
|
||||
void relay_txs_by_hash(const std::vector<std::string>& tx_hashes) override;
|
||||
std::shared_ptr<monero_tx_pool_stats> get_tx_pool_stats() override;
|
||||
std::vector<std::shared_ptr<monero_tx>> get_tx_pool() override;
|
||||
std::vector<std::string> get_tx_pool_hashes() override;
|
||||
void flush_tx_pool(const std::vector<std::string> &hashes) override;
|
||||
void flush_tx_pool() override;
|
||||
void flush_tx_pool(const std::string &hash) override;
|
||||
std::vector<monero_key_image_spent_status> get_key_image_spent_statuses(const std::vector<std::string>& key_images) override;
|
||||
std::vector<std::shared_ptr<monero_output>> get_outputs(const std::vector<monero_output>& outputs) override;
|
||||
std::vector<std::shared_ptr<monero_output_histogram_entry>> get_output_histogram(const std::vector<uint64_t>& amounts, const boost::optional<int>& min_count, const boost::optional<int>& max_count, const boost::optional<bool>& is_unlocked, const boost::optional<int>& recent_cutoff) override;
|
||||
std::vector<std::shared_ptr<monero_output_distribution_entry>> get_output_distribution(const std::vector<uint64_t>& amounts, const boost::optional<bool>& is_cumulative = boost::none, const boost::optional<uint64_t>& start_height = boost::none, const boost::optional<uint64_t>& end_height = boost::none) override;
|
||||
std::shared_ptr<monero_daemon_info> get_info() override;
|
||||
std::shared_ptr<monero_daemon_sync_info> get_sync_info() override;
|
||||
std::shared_ptr<monero_hard_fork_info> get_hard_fork_info() override;
|
||||
std::vector<std::shared_ptr<monero_alt_chain>> get_alt_chains() override;
|
||||
std::vector<std::string> get_alt_block_hashes() override;
|
||||
int get_download_limit() override;
|
||||
int set_download_limit(int limit) override;
|
||||
int reset_download_limit() override;
|
||||
int get_upload_limit() override;
|
||||
int set_upload_limit(int limit) override;
|
||||
int reset_upload_limit() override;
|
||||
std::vector<std::shared_ptr<monero_peer>> get_peers() override;
|
||||
std::vector<std::shared_ptr<monero_peer>> get_known_peers() override;
|
||||
void set_outgoing_peer_limit(int limit) override;
|
||||
void set_incoming_peer_limit(int limit) override;
|
||||
std::vector<std::shared_ptr<monero_ban>> get_peer_bans() override;
|
||||
void set_peer_bans(const std::vector<std::shared_ptr<monero_ban>>& bans) override;
|
||||
void start_mining(const std::string &address, boost::optional<uint64_t> num_threads, boost::optional<bool> background_mining, boost::optional<bool> ignore_battery) override;
|
||||
void stop_mining() override;
|
||||
std::shared_ptr<monero_mining_status> get_mining_status() override;
|
||||
std::shared_ptr<monero_generate_blocks_result> generate_blocks(const std::string& wallet_address, uint64_t num_blocks, const boost::optional<std::string>& prev_block_hash = boost::none, const boost::optional<uint32_t>& starting_nonce = boost::none) override;
|
||||
void submit_blocks(const std::vector<std::string>& block_blobs) override;
|
||||
std::shared_ptr<monero_prune_result> prune_blockchain(bool check) override;
|
||||
std::shared_ptr<monero_daemon_update_check_result> check_for_update() override;
|
||||
std::shared_ptr<monero_daemon_update_download_result> download_update(const std::string& path = "") override;
|
||||
void stop() override;
|
||||
std::shared_ptr<monero_block_header> wait_for_next_block_header() override;
|
||||
|
||||
// --------------------------------- PRIVATE --------------------------------
|
||||
|
||||
private:
|
||||
friend class monero_daemon_poller;
|
||||
mutable boost::recursive_mutex m_listeners_mutex;
|
||||
std::set<monero_daemon_listener*> m_listeners;
|
||||
std::shared_ptr<monero_rpc_connection> m_rpc;
|
||||
boost::mutex m_poller_mutex;
|
||||
std::unique_ptr<monero_daemon_poller> m_poller;
|
||||
|
||||
// header_cache is scoped to a single get_blocks_by_range_chunked() call (see below) rather than
|
||||
// stored as a member: it only helps avoid re-fetching a header already seen earlier in that one
|
||||
// chunking pass, and keeping it as instance state would let it grow unbounded over the connection's
|
||||
// lifetime and serve stale headers across reorgs on later calls
|
||||
std::vector<std::shared_ptr<monero_block>> get_max_blocks(boost::optional<uint64_t> start_height, boost::optional<uint64_t> max_height, boost::optional<uint64_t> chunk_size, std::unordered_map<uint64_t, std::shared_ptr<monero_block_header>>& header_cache);
|
||||
std::shared_ptr<monero_block_header> get_block_header_by_height_cached(uint64_t height, uint64_t max_height, std::unordered_map<uint64_t, std::shared_ptr<monero_block_header>>& header_cache);
|
||||
std::shared_ptr<monero_bandwidth_limits> get_bandwidth_limits();
|
||||
std::shared_ptr<monero_bandwidth_limits> set_bandwidth_limits(int up, int down);
|
||||
void refresh_listening();
|
||||
void wait_for_listener_callbacks_idle();
|
||||
};
|
||||
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,288 @@
|
||||
/**
|
||||
* Copyright (c) everoddandeven
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*
|
||||
* Parts of this file are originally copyright (c) 2025-2026 woodser
|
||||
*
|
||||
* Parts of this file are originally copyright (c) 2014-2019, The Monero Project
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification, are
|
||||
* permitted provided that the following conditions are met:
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
* 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 "common/monero_rpc_connection.h"
|
||||
|
||||
/**
|
||||
* Internal data model for monero_daemon_rpc.h.
|
||||
*/
|
||||
namespace monero {
|
||||
|
||||
/**
|
||||
* Models a Monero RPC banhammer.
|
||||
*/
|
||||
struct monero_rpc_ban : public monero_ban {
|
||||
monero_rpc_ban(const std::shared_ptr<monero_ban> &ban);
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
// ------------------------------ Binary Request ---------------------------------
|
||||
|
||||
/**
|
||||
* Models paramaters for monerod-rpc `/get_blocks_by_height.bin` method.
|
||||
*/
|
||||
struct monero_get_blocks_by_height_request : public monero_rpc_request {
|
||||
std::vector<uint64_t> m_heights;
|
||||
|
||||
monero_get_blocks_by_height_request(uint64_t num_blocks);
|
||||
monero_get_blocks_by_height_request(const std::vector<uint64_t>& heights): m_heights(heights) { m_method = "get_blocks_by_height.bin"; }
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
// ------------------------------ RPC Params ---------------------------------
|
||||
|
||||
struct monero_download_update_params : public serializable_struct {
|
||||
boost::optional<std::string> m_command;
|
||||
boost::optional<std::string> m_path;
|
||||
|
||||
monero_download_update_params(const std::string& command = "download", const std::string& path = "");
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
struct monero_submit_tx_params : public serializable_struct {
|
||||
boost::optional<std::string> m_tx_hex;
|
||||
boost::optional<bool> m_do_not_relay;
|
||||
std::vector<std::string> m_tx_hashes;
|
||||
|
||||
monero_submit_tx_params(const std::vector<std::string>& tx_hashes): m_tx_hashes(tx_hashes) { }
|
||||
monero_submit_tx_params(const std::string& tx_hex, bool do_not_relay): m_tx_hex(tx_hex), m_do_not_relay(do_not_relay) { }
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
struct monero_peer_limits_params : public serializable_struct {
|
||||
boost::optional<int> m_in_peers;
|
||||
boost::optional<int> m_out_peers;
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
struct monero_get_txs_params : public serializable_struct {
|
||||
std::vector<std::string> m_tx_hashes;
|
||||
boost::optional<bool> m_decode_as_json;
|
||||
boost::optional<bool> m_prune;
|
||||
|
||||
monero_get_txs_params(const std::vector<std::string> &tx_hashes, bool prune, bool decode_as_json = true): m_tx_hashes(tx_hashes), m_prune(prune), m_decode_as_json(decode_as_json) { }
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
struct monero_is_key_image_spent_params : public serializable_struct {
|
||||
std::vector<std::string> m_key_images;
|
||||
|
||||
monero_is_key_image_spent_params(const std::vector<std::string>& key_images): m_key_images(key_images) { }
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
// ------------------------------ JSON-RPC Params ---------------------------------
|
||||
|
||||
struct monero_start_mining_params : public serializable_struct {
|
||||
boost::optional<std::string> m_miner_address;
|
||||
boost::optional<uint64_t> m_num_threads;
|
||||
boost::optional<bool> m_is_background;
|
||||
boost::optional<bool> m_ignore_battery;
|
||||
|
||||
monero_start_mining_params(const boost::optional<std::string>& address, const boost::optional<uint64_t>& num_threads, const boost::optional<bool>& is_background, const boost::optional<bool>& ignore_battery): m_miner_address(address), m_num_threads(num_threads), m_is_background(is_background), m_ignore_battery(ignore_battery) { }
|
||||
monero_start_mining_params(const boost::optional<uint64_t>& num_threads, const boost::optional<bool>& is_background, const boost::optional<bool>& ignore_battery): m_num_threads(num_threads), m_is_background(is_background), m_ignore_battery(ignore_battery) { }
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
struct monero_generate_blocks_params : public serializable_struct {
|
||||
boost::optional<std::string> m_wallet_address;
|
||||
boost::optional<uint64_t> m_num_blocks;
|
||||
boost::optional<std::string> m_prev_block_hash;
|
||||
boost::optional<uint32_t> m_starting_nonce;
|
||||
|
||||
monero_generate_blocks_params(const std::string& wallet_address, uint64_t num_blocks, const boost::optional<std::string>& prev_block_hash, const boost::optional<uint32_t>& starting_nonce): m_wallet_address(wallet_address), m_num_blocks(num_blocks), m_prev_block_hash(prev_block_hash), m_starting_nonce(starting_nonce) { }
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
struct monero_prune_blockchain_params : public serializable_struct {
|
||||
boost::optional<bool> m_check;
|
||||
|
||||
monero_prune_blockchain_params(bool check = true): m_check(check) { }
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
struct monero_submit_blocks_params : public serializable_struct {
|
||||
std::vector<std::string> m_block_blobs;
|
||||
|
||||
monero_submit_blocks_params(const std::vector<std::string>& block_blobs): m_block_blobs(block_blobs) { }
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
struct monero_get_block_params : public serializable_struct {
|
||||
boost::optional<uint64_t> m_height;
|
||||
boost::optional<std::string> m_hash;
|
||||
boost::optional<bool> m_fill_pow_hash;
|
||||
boost::optional<uint64_t> m_start_height;
|
||||
boost::optional<uint64_t> m_end_height;
|
||||
boost::optional<std::string> m_wallet_address;
|
||||
boost::optional<int> m_reserve_size;
|
||||
|
||||
monero_get_block_params(uint64_t height, bool fill_pow_hash = false): m_height(height), m_fill_pow_hash(fill_pow_hash) { }
|
||||
monero_get_block_params(const std::string& hash, bool fill_pow_hash = false): m_hash(hash), m_fill_pow_hash(fill_pow_hash) { }
|
||||
monero_get_block_params(uint64_t start_height, uint64_t end_height): m_start_height(start_height), m_end_height(end_height) { }
|
||||
monero_get_block_params(const std::string& wallet_address, const boost::optional<int>& reserve_size): m_wallet_address(wallet_address), m_reserve_size(reserve_size) { }
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
struct monero_get_block_hash_params : public serializable_struct {
|
||||
boost::optional<uint64_t> m_height;
|
||||
|
||||
monero_get_block_hash_params(uint64_t height): m_height(height) { }
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
struct monero_get_miner_tx_sum_params : public serializable_struct {
|
||||
boost::optional<uint64_t> m_height;
|
||||
boost::optional<uint64_t> m_count;
|
||||
|
||||
monero_get_miner_tx_sum_params(uint64_t height, uint64_t count): m_height(height), m_count(count) { }
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
struct monero_get_fee_estimate_params : public serializable_struct {
|
||||
boost::optional<uint64_t> m_grace_blocks;
|
||||
|
||||
monero_get_fee_estimate_params(uint64_t grace_blocks = 0): m_grace_blocks(grace_blocks) { }
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
struct monero_set_bans_params : public serializable_struct {
|
||||
std::vector<std::shared_ptr<monero_rpc_ban>> m_bans;
|
||||
|
||||
monero_set_bans_params(const std::vector<std::shared_ptr<monero_ban>>& bans);
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
struct monero_get_output_histogram_params : public serializable_struct {
|
||||
std::vector<uint64_t> m_amounts;
|
||||
boost::optional<int> m_min_count;
|
||||
boost::optional<int> m_max_count;
|
||||
boost::optional<bool> m_is_unlocked;
|
||||
boost::optional<int> m_recent_cutoff;
|
||||
|
||||
monero_get_output_histogram_params(const std::vector<uint64_t>& amounts, const boost::optional<int>& min_count, const boost::optional<int>& max_count, const boost::optional<bool>& is_unlocked, const boost::optional<int>& recent_cutoff) : m_amounts(amounts), m_min_count(min_count), m_max_count(max_count), m_is_unlocked(is_unlocked), m_recent_cutoff(recent_cutoff) { }
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
struct monero_get_output_distribution_params : public serializable_struct {
|
||||
std::vector<uint64_t> m_amounts;
|
||||
boost::optional<bool> m_cumulative;
|
||||
boost::optional<bool> m_binary;
|
||||
boost::optional<uint64_t> m_from_height;
|
||||
boost::optional<uint64_t> m_to_height;
|
||||
|
||||
monero_get_output_distribution_params(const std::vector<uint64_t>& amounts, const boost::optional<bool>& cumulative, const boost::optional<uint64_t>& from_height, const boost::optional<uint64_t>& to_height) : m_amounts(amounts), m_cumulative(cumulative), m_from_height(from_height), m_to_height(to_height), m_binary(false) { }
|
||||
|
||||
rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
|
||||
};
|
||||
|
||||
// ------------------------------ JSON-RPC Response ---------------------------------
|
||||
|
||||
struct monero_get_block_result {
|
||||
boost::optional<uint64_t> m_count;
|
||||
boost::optional<uint64_t> m_height;
|
||||
boost::optional<bool> m_untrusted;
|
||||
|
||||
static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_get_block_result>& result);
|
||||
};
|
||||
|
||||
// ------------------------------ RPC Deserialization ---------------------------------
|
||||
|
||||
void deserialize_version(const boost::property_tree::ptree& node, monero_version& version);
|
||||
void deserialize_block_header(const boost::property_tree::ptree& node, const std::shared_ptr<monero_block_header>& header);
|
||||
void deserialize_block_headers(const boost::property_tree::ptree& node, std::vector<std::shared_ptr<monero_block_header>>& headers);
|
||||
void deserialize_block(const boost::property_tree::ptree& node, const std::shared_ptr<monero_block>& block, bool is_nested = false);
|
||||
void deserialize_blocks(const boost::property_tree::ptree& node, const std::vector<uint64_t>& heights, std::vector<std::shared_ptr<monero_block>>& blocks);
|
||||
void deserialize_alt_block_hashes(const boost::property_tree::ptree& node, std::vector<std::string>& block_hashes);
|
||||
void deserialize_txs(const boost::property_tree::ptree& node, std::vector<std::shared_ptr<monero_tx>>& txs);
|
||||
void deserialize_tx_hashes(const boost::property_tree::ptree& node, std::vector<std::string>& tx_hashes);
|
||||
void deserialize_key_image_spent_status(const boost::property_tree::ptree& node, std::vector<monero_key_image_spent_status>& statuses);
|
||||
void deserialize_alt_chains(const boost::property_tree::ptree& node, std::vector<std::shared_ptr<monero_alt_chain>>& alt_chains);
|
||||
void deserialize_bans(const boost::property_tree::ptree& node, std::vector<std::shared_ptr<monero_ban>>& bans);
|
||||
void deserialize_prune_result(const boost::property_tree::ptree& node, const std::shared_ptr<monero_prune_result>& result);
|
||||
void deserialize_mining_status(const boost::property_tree::ptree& node, const std::shared_ptr<monero_mining_status>& status);
|
||||
void deserialize_generate_blocks_result(const boost::property_tree::ptree& node, const std::shared_ptr<monero_generate_blocks_result>& result);
|
||||
void deserialize_miner_tx_sum(const boost::property_tree::ptree& node, const std::shared_ptr<monero_miner_tx_sum>& sum);
|
||||
void deserialize_block_template(const boost::property_tree::ptree& node, const std::shared_ptr<monero_block_template>& tmplt);
|
||||
void deserialize_peers(const boost::property_tree::ptree& node, std::vector<std::shared_ptr<monero_peer>>& peers);
|
||||
void deserialize_submit_tx_result(const boost::property_tree::ptree& node, const std::shared_ptr<monero_submit_tx_result>& result);
|
||||
void deserialize_output_distribution_entries(const boost::property_tree::ptree& node, std::vector<std::shared_ptr<monero_output_distribution_entry>>& entries);
|
||||
void deserialize_output_histogram_entries(const boost::property_tree::ptree& node, std::vector<std::shared_ptr<monero_output_histogram_entry>>& entries);
|
||||
void deserialize_tx_pool_stats(const boost::property_tree::ptree& node, const std::shared_ptr<monero_tx_pool_stats>& stats);
|
||||
void deserialize_update_check_result(const boost::property_tree::ptree& node, const std::shared_ptr<monero_daemon_update_check_result>& check);
|
||||
void deserialize_update_download_result(const boost::property_tree::ptree& node, const std::shared_ptr<monero_daemon_update_download_result>& check);
|
||||
void deserialize_fee_estimate(const boost::property_tree::ptree& node, const std::shared_ptr<monero_fee_estimate>& estimate);
|
||||
void deserialize_daemon_info(const boost::property_tree::ptree& node, const std::shared_ptr<monero_daemon_info>& info);
|
||||
void deserialize_daemon_sync_info(const boost::property_tree::ptree& node, const std::shared_ptr<monero_daemon_sync_info>& info);
|
||||
void deserialize_hard_fork_info(const boost::property_tree::ptree& node, const std::shared_ptr<monero_hard_fork_info>& info);
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user