Line data    Source code

       1             : // Copyright (c) 2021-2022 The Bitcoin Core developers
       2             : // Distributed under the MIT software license, see the accompanying
       3             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4             : 
       5             : #ifndef BITCOIN_NODE_CHAINSTATE_H
       6             : #define BITCOIN_NODE_CHAINSTATE_H
       7             : 
       8             : #include <util/translation.h>
       9             : #include <validation.h>
      10             : 
      11             : #include <cstdint>
      12             : #include <functional>
      13             : #include <tuple>
      14             : 
      15             : class CTxMemPool;
      16             : 
      17             : namespace node {
      18             : 
      19             : struct CacheSizes;
      20             : 
      21           1 : struct ChainstateLoadOptions {
      22           1 :     CTxMemPool* mempool{nullptr};
      23           1 :     bool block_tree_db_in_memory{false};
      24           1 :     bool coins_db_in_memory{false};
      25           1 :     bool reindex{false};
      26           1 :     bool reindex_chainstate{false};
      27           1 :     bool prune{false};
      28             :     //! Setting require_full_verification to true will require all checks at
      29             :     //! check_level (below) to succeed for loading to succeed. Setting it to
      30             :     //! false will skip checks if cache is not big enough to run them, so may be
      31             :     //! helpful for running with a small cache.
      32           1 :     bool require_full_verification{true};
      33           1 :     int64_t check_blocks{DEFAULT_CHECKBLOCKS};
      34           1 :     int64_t check_level{DEFAULT_CHECKLEVEL};
      35             :     std::function<bool()> check_interrupt;
      36             :     std::function<void()> coins_error_cb;
      37             : };
      38             : 
      39             : //! Chainstate load status. Simple applications can just check for the success
      40             : //! case, and treat other cases as errors. More complex applications may want to
      41             : //! try reindexing in the generic failure case, and pass an interrupt callback
      42             : //! and exit cleanly in the interrupted case.
      43             : enum class ChainstateLoadStatus {
      44             :     SUCCESS,
      45             :     FAILURE, //!< Generic failure which reindexing may fix
      46             :     FAILURE_FATAL, //!< Fatal error which should not prompt to reindex
      47             :     FAILURE_INCOMPATIBLE_DB,
      48             :     FAILURE_INSUFFICIENT_DBCACHE,
      49             :     INTERRUPTED,
      50             : };
      51             : 
      52             : //! Chainstate load status code and optional error string.
      53             : using ChainstateLoadResult = std::tuple<ChainstateLoadStatus, bilingual_str>;
      54             : 
      55             : /** This sequence can have 4 types of outcomes:
      56             :  *
      57             :  *  1. Success
      58             :  *  2. Shutdown requested
      59             :  *    - nothing failed but a shutdown was triggered in the middle of the
      60             :  *      sequence
      61             :  *  3. Soft failure
      62             :  *    - a failure that might be recovered from with a reindex
      63             :  *  4. Hard failure
      64             :  *    - a failure that definitively cannot be recovered from with a reindex
      65             :  *
      66             :  *  LoadChainstate returns a (status code, error string) tuple.
      67             :  */
      68             : ChainstateLoadResult LoadChainstate(ChainstateManager& chainman, const CacheSizes& cache_sizes,
      69             :                                     const ChainstateLoadOptions& options);
      70             : ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager& chainman, const ChainstateLoadOptions& options);
      71             : } // namespace node
      72             : 
      73             : #endif // BITCOIN_NODE_CHAINSTATE_H