14 #include <txmempool.h>
20 #include <validation.h>
41 if (load_path.empty())
return false;
43 FILE* filestr{opts.mockable_fopen_function(load_path,
"rb")};
46 LogPrintf(
"Failed to open mempool file from disk. Continuing anyway.\n");
53 int64_t already_there = 0;
54 int64_t unbroadcast = 0;
74 if (opts.use_current_time) {
75 nTime = TicksSinceEpoch<std::chrono::seconds>(now);
78 CAmount amountdelta = nFeeDelta;
79 if (amountdelta && opts.apply_fee_delta_priority) {
82 if (nTime > TicksSinceEpoch<std::chrono::seconds>(now - pool.
m_expiry)) {
104 std::map<uint256, CAmount> mapDeltas;
107 if (opts.apply_fee_delta_priority) {
108 for (
const auto& i : mapDeltas) {
113 std::set<uint256> unbroadcast_txids;
114 file >> unbroadcast_txids;
115 if (opts.apply_unbroadcast_set) {
116 unbroadcast = unbroadcast_txids.size();
117 for (
const auto& txid : unbroadcast_txids) {
123 }
catch (
const std::exception& e) {
124 LogPrintf(
"Failed to deserialize mempool data on disk: %s. Continuing anyway.\n", e.what());
128 LogPrintf(
"Imported mempool transactions from disk: %i succeeded, %i failed, %i expired, %i already there, %i waiting for initial broadcast\n",
count, failed, expired, already_there, unbroadcast);
134 auto start = SteadyClock::now();
136 std::map<uint256, CAmount> mapDeltas;
137 std::vector<TxMempoolInfo> vinfo;
138 std::set<uint256> unbroadcast_txids;
140 static Mutex dump_mutex;
145 for (
const auto &i : pool.mapDeltas) {
146 mapDeltas[i.first] = i.second;
152 auto mid = SteadyClock::now();
155 FILE* filestr{mockable_fopen_function(dump_path +
".new",
"wb")};
165 file << (uint64_t)vinfo.size();
166 for (
const auto& i : vinfo) {
169 file << int64_t{i.nFeeDelta};
170 mapDeltas.erase(i.tx->GetHash());
175 LogPrintf(
"Writing %d unbroadcast transactions to disk.\n", unbroadcast_txids.size());
176 file << unbroadcast_txids;
178 if (!skip_file_commit && !
FileCommit(file.Get()))
179 throw std::runtime_error(
"FileCommit failed");
181 if (!
RenameOver(dump_path +
".new", dump_path)) {
182 throw std::runtime_error(
"Rename failed");
184 auto last = SteadyClock::now();
186 LogPrintf(
"Dumped mempool: %gs to copy, %gs to dump\n",
187 Ticks<SecondsDouble>(mid - start),
188 Ticks<SecondsDouble>(last - mid));
189 }
catch (
const std::exception& e) {
190 LogPrintf(
"Failed to dump mempool: %s. Continuing anyway.\n", e.what());
int64_t CAmount
Amount in satoshis (Can be negative)
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
void PrioritiseTransaction(const uint256 &hash, const CAmount &nFeeDelta)
Affect CreateNewBlock prioritisation of transactions.
void AddUnbroadcastTx(const uint256 &txid)
Adds a transaction to the unbroadcast set.
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it.
const std::chrono::seconds m_expiry
CTransactionRef get(const uint256 &hash) const
std::vector< TxMempoolInfo > infoAll() const
std::set< uint256 > GetUnbroadcastTxs() const
Returns transactions in unbroadcast set.
bool exists(const GenTxid >xid) const
Chainstate stores and provides an API to update our local knowledge of the current best chain.
ChainstateManager & m_chainman
The chainstate manager that owns this chainstate.
const util::SignalInterrupt & m_interrupt
static GenTxid Txid(const uint256 &hash)
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
static const int CLIENT_VERSION
bitcoind-res.rc includes this file, but it cannot cope with real c++ code.
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
bool RenameOver(fs::path src, fs::path dest)
Rename src to dest.
bool FileCommit(FILE *file)
Ensure file contents are fully committed to disk, using a platform-specific feature analogous to fsyn...
std::function< FILE *(const fs::path &, const char *)> FopenFn
bool LoadMempool(CTxMemPool &pool, const fs::path &load_path, Chainstate &active_chainstate, ImportMempoolOptions &&opts)
Import the file and attempt to add its contents to the mempool.
bool DumpMempool(const CTxMemPool &pool, const fs::path &dump_path, FopenFn mockable_fopen_function, bool skip_file_commit)
static const uint64_t MEMPOOL_DUMP_VERSION
std::shared_ptr< const CTransaction > CTransactionRef
static time_point now() noexcept
Return current system time or mocked time, if set.
constexpr int64_t count_seconds(std::chrono::seconds t)
MempoolAcceptResult AcceptToMemoryPool(Chainstate &active_chainstate, const CTransactionRef &tx, int64_t accept_time, bool bypass_limits, bool test_accept) EXCLUSIVE_LOCKS_REQUIRED(
Try to add a transaction to the mempool.