chain.h

Go to the documentation of this file.

// Copyright (c) 2018-2019 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_INTERFACES_CHAIN_H
#define BITCOIN_INTERFACES_CHAIN_H
 
#include <primitives/transaction.h>
#include <primitives/txid.h>
#include <util/settings.h> // For util::SettingsValue
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
class ArgsManager;
class CBlock;
class CChainParams;
class Coin;
class Config;
class CRPCCommand;
class CScheduler;
class TxValidationState;
 
enum class MemPoolRemovalReason;
 
struct BlockHash;
struct bilingual_str;
struct CBlockLocator;
namespace node {
struct NodeContext;
} // namespace node
 
namespace Consensus {
struct Params;
}
 
namespace interfaces {
 
class Handler;
class Wallet;
 
class FoundBlock {
public:
    FoundBlock &hash(BlockHash &hash) {
        m_hash = &hash;
        return *this;
    }
    FoundBlock &height(int &height) {
        m_height = &height;
        return *this;
    }
    FoundBlock &time(int64_t &time) {
        m_time = &time;
        return *this;
    }
    FoundBlock &maxTime(int64_t &max_time) {
        m_max_time = &max_time;
        return *this;
    }
    FoundBlock &mtpTime(int64_t &mtp_time) {
        m_mtp_time = &mtp_time;
        return *this;
    }
    FoundBlock &inActiveChain(bool &in_active_chain) {
        m_in_active_chain = &in_active_chain;
        return *this;
    }
    FoundBlock &nextBlock(const FoundBlock &next_block) {
        m_next_block = &next_block;
        return *this;
    }
    FoundBlock &data(CBlock &data) {
        m_data = &data;
        return *this;
    }
 
    BlockHash *m_hash = nullptr;
    int *m_height = nullptr;
    int64_t *m_time = nullptr;
    int64_t *m_max_time = nullptr;
    int64_t *m_mtp_time = nullptr;
    bool *m_in_active_chain = nullptr;
    const FoundBlock *m_next_block = nullptr;
    CBlock *m_data = nullptr;
};
 
class Chain {
public:
    virtual ~Chain() {}
 
    virtual std::optional<int> getHeight() = 0;
 
    virtual BlockHash getBlockHash(int height) = 0;
 
    virtual bool haveBlockOnDisk(int height) = 0;
 
    virtual CBlockLocator getTipLocator() = 0;
 
    virtual std::optional<int>
    findLocatorFork(const CBlockLocator &locator) = 0;
 
    virtual bool findBlock(const BlockHash &hash,
                           const FoundBlock &block = {}) = 0;
 
    virtual bool
    findFirstBlockWithTimeAndHeight(int64_t min_time, int min_height,
                                    const FoundBlock &block = {}) = 0;
 
    virtual bool findAncestorByHeight(const BlockHash &block_hash,
                                      int ancestor_height,
                                      const FoundBlock &ancestor_out = {}) = 0;
 
    virtual bool findAncestorByHash(const BlockHash &block_hash,
                                    const BlockHash &ancestor_hash,
                                    const FoundBlock &ancestor_out = {}) = 0;
 
    virtual bool findCommonAncestor(const BlockHash &block_hash1,
                                    const BlockHash &block_hash2,
                                    const FoundBlock &ancestor_out = {},
                                    const FoundBlock &block1_out = {},
                                    const FoundBlock &block2_out = {}) = 0;
 
    virtual void findCoins(std::map<COutPoint, Coin> &coins) = 0;
 
    virtual double guessVerificationProgress(const BlockHash &block_hash) = 0;
 
    virtual bool hasBlocks(const BlockHash &block_hash, int min_height = 0,
                           std::optional<int> max_height = {}) = 0;
 
    virtual bool hasDescendantsInMempool(const TxId &txid) = 0;
 
    virtual bool broadcastTransaction(const Config &config,
                                      const CTransactionRef &tx,
                                      const Amount &max_tx_fee, bool relay,
                                      std::string &err_string) = 0;
 
    virtual void getTransactionAncestry(const TxId &txid, size_t &ancestors,
                                        size_t &descendants,
                                        size_t *ancestorsize = nullptr,
                                        Amount *ancestorfees = nullptr) = 0;
 
    virtual void getPackageLimits(size_t &limit_ancestor_count,
                                  size_t &limit_descendant_count) = 0;
 
    virtual bool checkChainLimits(const CTransactionRef &tx) = 0;
 
    virtual CFeeRate estimateFee() const = 0;
 
    virtual CFeeRate relayMinFee() = 0;
 
    virtual CFeeRate relayDustFee() = 0;
 
    virtual bool havePruned() = 0;
 
    virtual bool isReadyToBroadcast() = 0;
 
    virtual bool isInitialBlockDownload() = 0;
 
    virtual bool shutdownRequested() = 0;
 
    virtual int64_t getAdjustedTime() = 0;
 
    virtual void initMessage(const std::string &message) = 0;
 
    virtual void initWarning(const bilingual_str &message) = 0;
 
    virtual void initError(const bilingual_str &message) = 0;
 
    virtual void showProgress(const std::string &title, int progress,
                              bool resume_possible) = 0;
 
    class Notifications {
    public:
        virtual ~Notifications() {}
        virtual void transactionAddedToMempool(const CTransactionRef &tx,
                                               uint64_t mempool_sequence) {}
        virtual void transactionRemovedFromMempool(const CTransactionRef &ptx,
                                                   MemPoolRemovalReason reason,
                                                   uint64_t mempool_sequence) {}
        virtual void blockConnected(const CBlock &block, int height) {}
        virtual void blockDisconnected(const CBlock &block, int height) {}
        virtual void updatedBlockTip() {}
        virtual void chainStateFlushed(const CBlockLocator &locator) {}
    };
 
    virtual std::unique_ptr<Handler>
    handleNotifications(std::shared_ptr<Notifications> notifications) = 0;
 
    virtual void waitForNotificationsIfTipChanged(const BlockHash &old_tip) = 0;
 
    virtual std::unique_ptr<Handler> handleRpc(const CRPCCommand &command) = 0;
 
    virtual bool rpcEnableDeprecated(const std::string &method) = 0;
 
    virtual void rpcRunLater(const std::string &name, std::function<void()> fn,
                             int64_t seconds) = 0;
 
    virtual int rpcSerializationFlags() = 0;
 
    virtual util::SettingsValue getRwSetting(const std::string &name) = 0;
 
    virtual bool updateRwSetting(const std::string &name,
                                 const util::SettingsValue &value) = 0;
 
    virtual void requestMempoolTransactions(Notifications &notifications) = 0;
 
    virtual const CChainParams &params() const = 0;
};
 
class ChainClient {
public:
    virtual ~ChainClient() {}
 
    virtual void registerRpcs() = 0;
 
    virtual bool verify() = 0;
 
    virtual bool load() = 0;
 
    virtual void start(CScheduler &scheduler) = 0;
 
    virtual void flush() = 0;
 
    virtual void stop() = 0;
 
    virtual void setMockTime(int64_t time) = 0;
};
 
std::unique_ptr<Chain> MakeChain(node::NodeContext &node,
                                 const CChainParams &params);
 
} // namespace interfaces
 
#endif // BITCOIN_INTERFACES_CHAIN_H