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 <optional.h>               // For Optional and nullopt
#include <primitives/transaction.h> // For CTransactionRef

#include <memory>
#include <stddef.h>
#include <stdint.h>
#include <string>
#include <vector>

class CBlock;
class CFeeRate;
class CRPCCommand;
class CScheduler;
class CValidationState;
class Coin;
class uint256;
enum class RBFTransactionState;
struct CBlockLocator;
struct FeeCalculation;

namespace interfaces {

class Handler;
class Wallet;

class Chain
{
public:
    virtual ~Chain() {}

    class Lock
    {
    public:
        virtual ~Lock() {}

        virtual Optional<int> getHeight() = 0;

        virtual Optional<int> getBlockHeight(const uint256& hash) = 0;

        virtual int getBlockDepth(const uint256& hash) = 0;

        virtual uint256 getBlockHash(int height) = 0;

        virtual int64_t getBlockTime(int height) = 0;

        virtual int64_t getBlockMedianTimePast(int height) = 0;

        virtual bool haveBlockOnDisk(int height) = 0;

        virtual Optional<int> findFirstBlockWithTimeAndHeight(int64_t time, int height, uint256* hash) = 0;

        virtual Optional<int> findPruned(int start_height = 0, Optional<int> stop_height = nullopt) = 0;

        virtual Optional<int> findFork(const uint256& hash, Optional<int>* height) = 0;

        virtual CBlockLocator getTipLocator() = 0;

        virtual Optional<int> findLocatorFork(const CBlockLocator& locator) = 0;

        virtual bool checkFinalTx(const CTransaction& tx) = 0;

        virtual bool submitToMemoryPool(const CTransactionRef& tx, CAmount absurd_fee, CValidationState& state) = 0;
    };

    virtual std::unique_ptr<Lock> lock(bool try_lock = false) = 0;

    virtual bool findBlock(const uint256& hash,
        CBlock* block = nullptr,
        int64_t* time = nullptr,
        int64_t* max_time = nullptr) = 0;

    virtual void findCoins(std::map<COutPoint, Coin>& coins) = 0;

    virtual double guessVerificationProgress(const uint256& block_hash) = 0;

    virtual RBFTransactionState isRBFOptIn(const CTransaction& tx) = 0;

    virtual bool hasDescendantsInMempool(const uint256& txid) = 0;

    virtual void relayTransaction(const uint256& txid) = 0;

    virtual void getTransactionAncestry(const uint256& txid, size_t& ancestors, size_t& descendants) = 0;

    virtual bool checkChainLimits(const CTransactionRef& tx) = 0;

    virtual CFeeRate estimateSmartFee(int num_blocks, bool conservative, FeeCalculation* calc = nullptr) = 0;

    virtual unsigned int estimateMaxBlocks() = 0;

    virtual CFeeRate mempoolMinFee() = 0;

    virtual CFeeRate relayMinFee() = 0;

    virtual CFeeRate relayIncrementalFee() = 0;

    virtual CFeeRate relayDustFee() = 0;

    virtual bool havePruned() = 0;

    virtual bool p2pEnabled() = 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 std::string& message) = 0;

    virtual void initError(const std::string& message) = 0;

    virtual void loadWallet(std::unique_ptr<Wallet> wallet) = 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) {}
        virtual void TransactionRemovedFromMempool(const CTransactionRef& ptx) {}
        virtual void BlockConnected(const CBlock& block, const std::vector<CTransactionRef>& tx_conflicted) {}
        virtual void BlockDisconnected(const CBlock& block) {}
        virtual void UpdatedBlockTip() {}
        virtual void ChainStateFlushed(const CBlockLocator& locator) {}
    };

    virtual std::unique_ptr<Handler> handleNotifications(Notifications& notifications) = 0;

    virtual void waitForNotificationsIfNewBlocksConnected(const uint256& 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 void requestMempoolTransactions(Notifications& notifications) = 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;
};

std::unique_ptr<Chain> MakeChain();

std::unique_ptr<ChainClient> MakeWalletClient(Chain& chain, std::vector<std::string> wallet_filenames);

} // namespace interfaces

#endif // BITCOIN_INTERFACES_CHAIN_H