DiviDevelopment/divi/src/BlockMemoryPoolTransactionCollector.h at 18d2b080276d64f30cce8b74861e8b3971ba5650 · DiviProject/DiviDevelopment · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
#ifndef BLOCK_MEMORY_POOL_TRANSACTION_COLLECTOR_H
#define BLOCK_MEMORY_POOL_TRANSACTION_COLLECTOR_H

#include <amount.h>
#include <FeeRate.h>
#include <uint256.h>

#include <list>
#include <memory>
#include <set>
#include <stdint.h>
#include <vector>

#include <boost/tuple/tuple.hpp>
#include <boost/thread/recursive_mutex.hpp>

#include <I_BlockTransactionCollector.h>

class BlockMap;
class CCriticalSection;
class CTxMemPoolEntry;
class CTransaction;
class CTxIn;
class CBlock;
class CCoinsViewCache;
class CBlockIndex;
class CTxMemPool;
class CBlockTemplate;
class CBlockHeader;
class CFeeRate;
class OutputHash;
class Settings;

struct PrioritizedTransactionData
{
    const CTransaction* tx;
    unsigned int transactionSigOpCount;
    CAmount fee;
    PrioritizedTransactionData();
    PrioritizedTransactionData(
        const CTransaction& transaction,
        unsigned transactionSigOps,
        CAmount feePaid);
};

class COrphan;

// We want to sort transactions by priority and fee rate, so:
typedef boost::tuple<double, CFeeRate, const CTransaction*,CAmount,unsigned> TxPriority;
class TxPriorityCompare;
class CChain;

class BlockMemoryPoolTransactionCollector: public I_BlockTransactionCollector
{
private:
    using DependingTransactionsMap = std::map<OutputHash, std::vector<std::shared_ptr<COrphan>>>;

    CCoinsViewCache* baseCoinsViewCache_;
    const CChain& activeChain_;
    const BlockMap& blockIndexMap_;
    CTxMemPool& mempool_;
    CCriticalSection& mainCS_;
    const CFeeRate& txFeeRate_;
    const unsigned blockMaxSize_;
    const unsigned blockPrioritySize_;
    const unsigned blockMinSize_;

private:
    void RecordOrphanTransaction(
        std::shared_ptr<COrphan>& porphan,
        const CTransaction& tx,
        const CTxIn& txin,
        DependingTransactionsMap& mapDependers) const;

    void ComputeTransactionPriority(
        const CTxMemPoolEntry& tx,
        const int nHeight,
        COrphan* porphan,
        std::vector<TxPriority>& vecPriority) const;
    void AddDependingTransactionsToPriorityQueue(
        DependingTransactionsMap& mapDependers,
        const OutputHash& hash,
        std::vector<TxPriority>& vecPriority,
        TxPriorityCompare& comparer) const;

    bool ShouldSkipCheapTransaction(
        const CFeeRate& feeRate,
        const uint64_t currentBlockSize,
        const unsigned int transactionSize) const;

    void AddTransactionToBlock(
        const CTransaction& tx,
        const CAmount feePaid,
        CBlock& block) const;

    std::vector<TxPriority> ComputeMempoolTransactionPriorities(
        const int& nHeight,
        DependingTransactionsMap& mapDependers,
        CCoinsViewCache& view) const;

    bool ShouldSwitchToPriotizationByFee(
        const uint64_t& currentBlockSize,
        const unsigned int& transactionSize,
        const bool mustPayFees) const;
    std::vector<PrioritizedTransactionData> PrioritizeTransactionsByBlockSpaceUsage(
        std::vector<TxPriority>& vecPriority,
        const int& nHeight,
        CCoinsViewCache& view,
        DependingTransactionsMap& mapDependers) const;
    void AddTransactionsToBlockIfPossible(
        const int& nHeight,
        CCoinsViewCache& view,
        CBlock& block) const;
public:
    BlockMemoryPoolTransactionCollector(
        const Settings& settings,
        CCoinsViewCache* baseCoinsViewCache,
        const CChain& activeChain,
        const BlockMap& blockIndexMap,
        CTxMemPool& mempool,
        CCriticalSection& mainCS,
        const CFeeRate& txFeeRate);
    bool CollectTransactionsIntoBlock(
        CBlockTemplate& pblocktemplate) const override;
};

#endif // BLOCK_MEMORY_POOL_TRANSACTION_COLLECTOR_H