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 <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;

struct BlockHash;
struct bilingual_str;
struct CBlockLocator;
struct NodeContext;

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 &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;
    CBlock *m_data = nullptr;
};

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

    virtual std::optional<int> getHeight() = 0;

    virtual std::optional<int> getBlockHeight(const BlockHash &hash) = 0;

    virtual BlockHash getBlockHash(int height) = 0;

    virtual bool haveBlockOnDisk(int height) = 0;

    virtual std::optional<int>
    findFirstBlockWithTimeAndHeight(int64_t time, int height,
                                    BlockHash *hash) = 0;

    virtual CBlockLocator getTipLocator() = 0;

    virtual std::optional<int>
    findLocatorFork(const CBlockLocator &locator) = 0;

    virtual bool
    contextualCheckTransactionForCurrentBlock(const CTransaction &tx,
                                              TxValidationState &state) = 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 findNextBlock(const BlockHash &block_hash, int block_height,
                               const FoundBlock &next = {},
                               bool *reorg = nullptr) = 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) = 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) {}
        virtual void transactionRemovedFromMempool(const CTransactionRef &ptx) {
        }
        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 void requestMempoolTransactions(Notifications &notifications) = 0;

    virtual const CChainParams &params() const = 0;
};

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

    virtual void registerRpcs() = 0;

    virtual bool verify(const CChainParams &chainParams) = 0;

    virtual bool load(const CChainParams &chainParams) = 0;

    virtual void start(CScheduler &scheduler) = 0;

    virtual void flush() = 0;

    virtual void stop() = 0;

    virtual void setMockTime(int64_t time) = 0;

    virtual std::vector<std::unique_ptr<Wallet>> getWallets() = 0;
};

std::unique_ptr<Chain> MakeChain(NodeContext &node, const CChainParams &params);

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

} // namespace interfaces

#endif // BITCOIN_INTERFACES_CHAIN_H