2021-08-22 04:20:59 -06:00
|
|
|
/*
|
|
|
|
* This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
|
2023-01-04 05:07:55 -07:00
|
|
|
* Copyright (c) 2021-2023 SChernykh <https://github.com/SChernykh>
|
2021-08-22 04:20:59 -06:00
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, version 3.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include "uv_util.h"
|
2022-11-02 05:49:12 -06:00
|
|
|
#include "pool_block.h"
|
2021-08-22 04:20:59 -06:00
|
|
|
#include <map>
|
2022-07-14 01:04:14 -06:00
|
|
|
#include <thread>
|
2021-08-22 04:20:59 -06:00
|
|
|
|
|
|
|
namespace p2pool {
|
|
|
|
|
|
|
|
class p2pool;
|
2021-11-01 11:53:34 -06:00
|
|
|
class P2PServer;
|
2021-08-22 04:20:59 -06:00
|
|
|
|
|
|
|
struct MinerShare
|
|
|
|
{
|
2022-11-15 14:20:54 -07:00
|
|
|
FORCEINLINE MinerShare() : m_weight(), m_wallet(nullptr) {}
|
|
|
|
FORCEINLINE MinerShare(const difficulty_type& w, const Wallet* x) : m_weight(w), m_wallet(x) {}
|
2021-08-22 04:20:59 -06:00
|
|
|
|
2023-01-10 08:33:19 -07:00
|
|
|
FORCEINLINE bool operator==(const MinerShare& s) const { return *m_wallet == *s.m_wallet; }
|
|
|
|
|
2022-11-15 14:20:54 -07:00
|
|
|
difficulty_type m_weight;
|
2022-07-10 02:24:03 -06:00
|
|
|
const Wallet* m_wallet;
|
2021-08-22 04:20:59 -06:00
|
|
|
};
|
|
|
|
|
2022-07-14 01:04:14 -06:00
|
|
|
class SideChain : public nocopy_nomove
|
2021-08-22 04:20:59 -06:00
|
|
|
{
|
|
|
|
public:
|
2021-09-06 07:49:39 -06:00
|
|
|
SideChain(p2pool* pool, NetworkType type, const char* pool_name = nullptr);
|
2021-08-22 04:20:59 -06:00
|
|
|
~SideChain();
|
|
|
|
|
2023-01-08 17:15:06 -07:00
|
|
|
void fill_sidechain_data(PoolBlock& block, std::vector<MinerShare>& shares) const;
|
2021-08-22 04:20:59 -06:00
|
|
|
|
2023-05-29 06:13:11 -06:00
|
|
|
bool incoming_block_seen(const PoolBlock& block);
|
|
|
|
void forget_incoming_block(const PoolBlock& block);
|
|
|
|
void cleanup_incoming_blocks();
|
2023-05-22 07:30:57 -06:00
|
|
|
|
2021-08-22 04:20:59 -06:00
|
|
|
bool add_external_block(PoolBlock& block, std::vector<hash>& missing_blocks);
|
2023-01-07 07:50:02 -07:00
|
|
|
bool add_block(const PoolBlock& block);
|
2023-07-10 06:11:22 -06:00
|
|
|
void get_missing_blocks(unordered_set<hash>& missing_blocks) const;
|
2021-08-22 04:20:59 -06:00
|
|
|
|
2022-05-12 07:19:58 -06:00
|
|
|
PoolBlock* find_block(const hash& id) const;
|
2021-09-06 15:33:52 -06:00
|
|
|
void watch_mainchain_block(const ChainMain& data, const hash& possible_id);
|
|
|
|
|
2023-07-07 08:42:24 -06:00
|
|
|
const PoolBlock* get_block_blob(const hash& id, std::vector<uint8_t>& blob) const;
|
2022-08-15 03:16:00 -06:00
|
|
|
bool get_outputs_blob(PoolBlock* block, uint64_t total_reward, std::vector<uint8_t>& blob, uv_loop_t* loop) const;
|
2021-08-22 04:20:59 -06:00
|
|
|
|
2022-08-23 06:13:09 -06:00
|
|
|
void print_status(bool obtain_sidechain_lock = true) const;
|
2022-05-28 14:27:46 -06:00
|
|
|
double get_reward_share(const Wallet& w) const;
|
2021-08-22 04:20:59 -06:00
|
|
|
|
|
|
|
// Consensus ID can be used to spawn independent P2Pools with their own sidechains
|
|
|
|
// It's never sent over the network to avoid revealing it to the possible man in the middle
|
|
|
|
// Consensus ID can therefore be used as a password to create private P2Pools
|
|
|
|
const std::vector<uint8_t>& consensus_id() const { return m_consensusId; }
|
|
|
|
uint64_t chain_window_size() const { return m_chainWindowSize; }
|
2023-01-16 06:18:34 -07:00
|
|
|
static NetworkType network_type() { return s_networkType; }
|
|
|
|
static uint64_t network_major_version(uint64_t height);
|
2022-05-09 08:07:49 -06:00
|
|
|
FORCEINLINE difficulty_type difficulty() const { ReadLock lock(m_curDifficultyLock); return m_curDifficulty; }
|
2021-09-01 08:26:56 -06:00
|
|
|
difficulty_type total_hashes() const;
|
|
|
|
uint64_t block_time() const { return m_targetBlockTime; }
|
2021-09-01 12:48:03 -06:00
|
|
|
uint64_t miner_count();
|
2022-03-23 04:30:38 -06:00
|
|
|
uint64_t last_updated() const;
|
2021-09-07 13:30:52 -06:00
|
|
|
bool is_default() const;
|
2021-12-30 03:10:18 -07:00
|
|
|
bool is_mini() const;
|
2023-03-28 05:28:34 -06:00
|
|
|
uint64_t bottom_height(const PoolBlock* tip) const;
|
2021-08-22 04:20:59 -06:00
|
|
|
|
2021-11-01 11:53:34 -06:00
|
|
|
const PoolBlock* chainTip() const { return m_chainTip; }
|
2022-09-13 02:51:15 -06:00
|
|
|
bool precalcFinished() const { return m_precalcFinished.load(); }
|
2021-11-01 11:53:34 -06:00
|
|
|
|
2023-01-07 16:34:38 -07:00
|
|
|
#ifdef P2POOL_UNIT_TESTS
|
|
|
|
difficulty_type m_testMainChainDiff;
|
2023-07-11 16:25:37 -06:00
|
|
|
const unordered_map<hash, PoolBlock*>& blocksById() const { return m_blocksById; }
|
2023-01-07 16:34:38 -07:00
|
|
|
#endif
|
|
|
|
|
2021-08-22 04:20:59 -06:00
|
|
|
static bool split_reward(uint64_t reward, const std::vector<MinerShare>& shares, std::vector<uint64_t>& rewards);
|
|
|
|
|
|
|
|
private:
|
|
|
|
p2pool* m_pool;
|
2021-11-01 12:35:11 -06:00
|
|
|
P2PServer* p2pServer() const;
|
2023-01-16 06:18:34 -07:00
|
|
|
static NetworkType s_networkType;
|
2021-08-22 04:20:59 -06:00
|
|
|
|
|
|
|
private:
|
2023-01-13 08:56:31 -07:00
|
|
|
bool get_shares(const PoolBlock* tip, std::vector<MinerShare>& shares, uint64_t* bottom_height = nullptr, bool quiet = false) const;
|
2022-07-10 02:24:03 -06:00
|
|
|
bool get_difficulty(const PoolBlock* tip, std::vector<DifficultyData>& difficultyData, difficulty_type& curDifficulty) const;
|
2021-08-22 04:20:59 -06:00
|
|
|
void verify_loop(PoolBlock* block);
|
|
|
|
void verify(PoolBlock* block);
|
2022-07-10 02:24:03 -06:00
|
|
|
void update_chain_tip(const PoolBlock* block);
|
2022-05-12 07:19:58 -06:00
|
|
|
PoolBlock* get_parent(const PoolBlock* block) const;
|
2021-08-22 04:20:59 -06:00
|
|
|
|
|
|
|
// Checks if "candidate" has longer (higher difficulty) chain than "block"
|
2023-03-06 06:52:47 -07:00
|
|
|
bool is_longer_chain(const PoolBlock* block, const PoolBlock* candidate, bool& is_alternative) const;
|
2021-08-22 04:20:59 -06:00
|
|
|
void update_depths(PoolBlock* block);
|
|
|
|
void prune_old_blocks();
|
|
|
|
|
|
|
|
bool load_config(const std::string& filename);
|
2022-12-22 05:33:44 -07:00
|
|
|
bool check_config() const;
|
2021-08-22 04:20:59 -06:00
|
|
|
|
2022-05-12 07:19:58 -06:00
|
|
|
mutable uv_rwlock_t m_sidechainLock;
|
2022-04-08 15:14:08 -06:00
|
|
|
std::atomic<PoolBlock*> m_chainTip;
|
2021-08-22 04:20:59 -06:00
|
|
|
std::map<uint64_t, std::vector<PoolBlock*>> m_blocksByHeight;
|
2021-10-22 10:18:38 -06:00
|
|
|
unordered_map<hash, PoolBlock*> m_blocksById;
|
2022-05-12 07:19:58 -06:00
|
|
|
|
|
|
|
uv_mutex_t m_seenWalletsLock;
|
2022-03-23 04:30:38 -06:00
|
|
|
unordered_map<hash, uint64_t> m_seenWallets;
|
2022-05-12 14:18:08 -06:00
|
|
|
uint64_t m_seenWalletsLastPruneTime;
|
2021-08-22 04:20:59 -06:00
|
|
|
|
2023-05-29 06:13:11 -06:00
|
|
|
// Used to quickly cut off multiple broadcasts of the same block by different peers. Only the first broadcast will be processed.
|
|
|
|
uv_mutex_t m_incomingBlocksLock;
|
|
|
|
unordered_map<PoolBlock::full_id, uint64_t> m_incomingBlocks;
|
2021-10-31 03:26:13 -06:00
|
|
|
|
2021-08-22 04:20:59 -06:00
|
|
|
std::vector<DifficultyData> m_difficultyData;
|
|
|
|
|
|
|
|
std::string m_poolName;
|
|
|
|
std::string m_poolPassword;
|
|
|
|
uint64_t m_targetBlockTime;
|
|
|
|
difficulty_type m_minDifficulty;
|
|
|
|
uint64_t m_chainWindowSize;
|
|
|
|
uint64_t m_unclePenalty;
|
|
|
|
|
|
|
|
std::vector<uint8_t> m_consensusId;
|
2022-03-23 07:17:40 -06:00
|
|
|
std::string m_consensusIdDisplayStr;
|
2021-08-22 04:20:59 -06:00
|
|
|
|
2022-05-09 08:07:49 -06:00
|
|
|
mutable uv_rwlock_t m_curDifficultyLock;
|
2021-08-22 04:20:59 -06:00
|
|
|
difficulty_type m_curDifficulty;
|
2021-09-06 15:33:52 -06:00
|
|
|
|
|
|
|
ChainMain m_watchBlock;
|
|
|
|
hash m_watchBlockSidechainId;
|
2022-07-14 01:04:14 -06:00
|
|
|
|
|
|
|
struct PrecalcJob
|
|
|
|
{
|
|
|
|
const PoolBlock* b;
|
2023-01-07 16:34:38 -07:00
|
|
|
std::vector<MinerShare> shares;
|
2022-07-14 01:04:14 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
uv_cond_t m_precalcJobsCond;
|
|
|
|
uv_mutex_t m_precalcJobsMutex;
|
|
|
|
|
|
|
|
std::vector<PrecalcJob*> m_precalcJobs;
|
|
|
|
std::vector<std::thread> m_precalcWorkers;
|
|
|
|
unordered_set<size_t>* m_uniquePrecalcInputs;
|
|
|
|
|
|
|
|
std::atomic<bool> m_precalcFinished;
|
|
|
|
|
2023-05-17 15:36:58 -06:00
|
|
|
#ifdef DEV_TEST_SYNC
|
2023-06-16 07:51:33 -06:00
|
|
|
uint64_t m_firstPruneTime;
|
2023-05-17 15:36:58 -06:00
|
|
|
#endif
|
|
|
|
|
2023-01-09 11:47:35 -07:00
|
|
|
hash m_consensusHash;
|
|
|
|
|
2022-07-14 01:04:14 -06:00
|
|
|
void launch_precalc(const PoolBlock* block);
|
|
|
|
void precalc_worker();
|
|
|
|
void finish_precalc();
|
2021-08-22 04:20:59 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace p2pool
|
2023-01-10 08:33:19 -07:00
|
|
|
|
|
|
|
namespace robin_hood {
|
|
|
|
|
|
|
|
template<>
|
|
|
|
struct hash<p2pool::MinerShare>
|
|
|
|
{
|
|
|
|
FORCEINLINE size_t operator()(const p2pool::MinerShare& value) const noexcept
|
|
|
|
{
|
|
|
|
return hash_bytes(value.m_wallet->spend_public_key().h, p2pool::HASH_SIZE);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace robin_hood
|