/workdir/bitcoin/src/versionbits.cpp

Source (jump to first uncovered line)
// Copyright (c) 2016-2022 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <consensus/params.h>
#include <util/check.h>
#include <versionbits.h>

ThresholdState AbstractThresholdConditionChecker::GetStateFor(const CBlockIndex* pindexPrev, const Consensus::Params& params, ThresholdConditionCache& cache) const
{
    int nPeriod = Period(params);
    int nThreshold = Threshold(params);
    int min_activation_height = MinActivationHeight(params);
    int64_t nTimeStart = BeginTime(params);
    int64_t nTimeTimeout = EndTime(params);

    // Check if this deployment is always active.
    if (nTimeStart == Consensus::BIP9Deployment::ALWAYS_ACTIVE) {
        return ThresholdState::ACTIVE;
    }

    // Check if this deployment is never active.
    if (nTimeStart == Consensus::BIP9Deployment::NEVER_ACTIVE) {
        return ThresholdState::FAILED;
    }

    // A block's state is always the same as that of the first of its period, so it is computed based on a pindexPrev whose height equals a multiple of nPeriod - 1.
    if (pindexPrev != nullptr) {
        pindexPrev = pindexPrev->GetAncestor(pindexPrev->nHeight - ((pindexPrev->nHeight + 1) % nPeriod));
    }

    // Walk backwards in steps of nPeriod to find a pindexPrev whose information is known
    std::vector<const CBlockIndex*> vToCompute;
    while (cache.count(pindexPrev) == 0) {
        if (pindexPrev == nullptr) {
            // The genesis block is by definition defined.
            cache[pindexPrev] = ThresholdState::DEFINED;
            break;
        }
        if (pindexPrev->GetMedianTimePast() < nTimeStart) {
            // Optimization: don't recompute down further, as we know every earlier block will be before the start time
            cache[pindexPrev] = ThresholdState::DEFINED;
            break;
        }
        vToCompute.push_back(pindexPrev);
        pindexPrev = pindexPrev->GetAncestor(pindexPrev->nHeight - nPeriod);
    }

    // At this point, cache[pindexPrev] is known
    assert(cache.count(pindexPrev));
    ThresholdState state = cache[pindexPrev];

    // Now walk forward and compute the state of descendants of pindexPrev
    while (!vToCompute.empty()) {
        ThresholdState stateNext = state;
        pindexPrev = vToCompute.back();
        vToCompute.pop_back();

        switch (state) {
            case ThresholdState::DEFINED: {
                if (pindexPrev->GetMedianTimePast() >= nTimeStart) {
                    stateNext = ThresholdState::STARTED;
                }
                break;
            }
            case ThresholdState::STARTED: {
                // We need to count
                const CBlockIndex* pindexCount = pindexPrev;
                int count = 0;
                for (int i = 0; i < nPeriod; i++) {
                    if (Condition(pindexCount, params)) {
                        count++;
                    }
                    pindexCount = pindexCount->pprev;
                }
                if (count >= nThreshold) {
                    stateNext = ThresholdState::LOCKED_IN;
                } else if (pindexPrev->GetMedianTimePast() >= nTimeTimeout) {
                    stateNext = ThresholdState::FAILED;
                }
                break;
            }
            case ThresholdState::LOCKED_IN: {
                // Progresses into ACTIVE provided activation height will have been reached.
                if (pindexPrev->nHeight + 1 >= min_activation_height) {
                    stateNext = ThresholdState::ACTIVE;
                }
                break;
            }
            case ThresholdState::FAILED:
            case ThresholdState::ACTIVE: {
                // Nothing happens, these are terminal states.
                break;
            }
        }
        cache[pindexPrev] = state = stateNext;
    }

    return state;
}

BIP9Stats AbstractThresholdConditionChecker::GetStateStatisticsFor(const CBlockIndex* pindex, const Consensus::Params& params, std::vector<bool>* signalling_blocks) const
{
    BIP9Stats stats = {};

    stats.period = Period(params);
    stats.threshold = Threshold(params);

    if (pindex == nullptr) return stats;

    // Find how many blocks are in the current period
    int blocks_in_period = 1 + (pindex->nHeight % stats.period);

    // Reset signalling_blocks
    if (signalling_blocks) {
        signalling_blocks->assign(blocks_in_period, false);
    }

    // Count from current block to beginning of period
    int elapsed = 0;
    int count = 0;
    const CBlockIndex* currentIndex = pindex;
    do {
        ++elapsed;
        --blocks_in_period;
        if (Condition(currentIndex, params)) {
            ++count;
            if (signalling_blocks) signalling_blocks->at(blocks_in_period) = true;
        }
        currentIndex = currentIndex->pprev;
    } while(blocks_in_period > 0);

    stats.elapsed = elapsed;
    stats.count = count;
    stats.possible = (stats.period - stats.threshold ) >= (stats.elapsed - count);

    return stats;
}

int AbstractThresholdConditionChecker::GetStateSinceHeightFor(const CBlockIndex* pindexPrev, const Consensus::Params& params, ThresholdConditionCache& cache) const
{
    int64_t start_time = BeginTime(params);
    if (start_time == Consensus::BIP9Deployment::ALWAYS_ACTIVE || start_time == Consensus::BIP9Deployment::NEVER_ACTIVE) {
        return 0;
    }

    const ThresholdState initialState = GetStateFor(pindexPrev, params, cache);

    // BIP 9 about state DEFINED: "The genesis block is by definition in this state for each deployment."
    if (initialState == ThresholdState::DEFINED) {
        return 0;
    }

    const int nPeriod = Period(params);

    // A block's state is always the same as that of the first of its period, so it is computed based on a pindexPrev whose height equals a multiple of nPeriod - 1.
    // To ease understanding of the following height calculation, it helps to remember that
    // right now pindexPrev points to the block prior to the block that we are computing for, thus:
    // if we are computing for the last block of a period, then pindexPrev points to the second to last block of the period, and
    // if we are computing for the first block of a period, then pindexPrev points to the last block of the previous period.
    // The parent of the genesis block is represented by nullptr.
    pindexPrev = Assert(pindexPrev->GetAncestor(pindexPrev->nHeight - ((pindexPrev->nHeight + 1) % nPeriod)));

    const CBlockIndex* previousPeriodParent = pindexPrev->GetAncestor(pindexPrev->nHeight - nPeriod);

    while (previousPeriodParent != nullptr && GetStateFor(previousPeriodParent, params, cache) == initialState) {
        pindexPrev = previousPeriodParent;
        previousPeriodParent = pindexPrev->GetAncestor(pindexPrev->nHeight - nPeriod);
    }

    // Adjust the result because right now we point to the parent block.
    return pindexPrev->nHeight + 1;
}

namespace
{
/**
 * Class to implement versionbits logic.
 */
class VersionBitsConditionChecker : public AbstractThresholdConditionChecker {
private:
    const Consensus::DeploymentPos id;

protected:
    int64_t BeginTime(const Consensus::Params& params) const override { return params.vDeployments[id].nStartTime; }
    int64_t EndTime(const Consensus::Params& params) const override { return params.vDeployments[id].nTimeout; }
    int MinActivationHeight(const Consensus::Params& params) const override { return params.vDeployments[id].min_activation_height; }
    int Period(const Consensus::Params& params) const override { return params.nMinerConfirmationWindow; }
    int Threshold(const Consensus::Params& params) const override { return params.nRuleChangeActivationThreshold; }

    bool Condition(const CBlockIndex* pindex, const Consensus::Params& params) const override
    {
        return (((pindex->nVersion & VERSIONBITS_TOP_MASK) == VERSIONBITS_TOP_BITS) && (pindex->nVersion & Mask(params)) != 0);
    }

public:
    explicit VersionBitsConditionChecker(Consensus::DeploymentPos id_) : id(id_) {}
    uint32_t Mask(const Consensus::Params& params) const { return (uint32_t{1}) << params.vDeployments[id].bit; }
};

} // namespace

ThresholdState VersionBitsCache::State(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::DeploymentPos pos)
{
    LOCK(m_mutex);
    return VersionBitsConditionChecker(pos).GetStateFor(pindexPrev, params, m_caches[pos]);
}

BIP9Stats VersionBitsCache::Statistics(const CBlockIndex* pindex, const Consensus::Params& params, Consensus::DeploymentPos pos, std::vector<bool>* signalling_blocks)
{
    return VersionBitsConditionChecker(pos).GetStateStatisticsFor(pindex, params, signalling_blocks);
}

int VersionBitsCache::StateSinceHeight(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::DeploymentPos pos)
{
    LOCK(m_mutex);
    return VersionBitsConditionChecker(pos).GetStateSinceHeightFor(pindexPrev, params, m_caches[pos]);
}

uint32_t VersionBitsCache::Mask(const Consensus::Params& params, Consensus::DeploymentPos pos)
{
    return VersionBitsConditionChecker(pos).Mask(params);
}

int32_t VersionBitsCache::ComputeBlockVersion(const CBlockIndex* pindexPrev, const Consensus::Params& params)
{
    LOCK(m_mutex);
    int32_t nVersion = VERSIONBITS_TOP_BITS;

    for (int i = 0; i < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; i++) {
        Consensus::DeploymentPos pos = static_cast<Consensus::DeploymentPos>(i);
        ThresholdState state = VersionBitsConditionChecker(pos).GetStateFor(pindexPrev, params, m_caches[pos]);
        if (state == ThresholdState::LOCKED_IN || state == ThresholdState::STARTED) {
            nVersion |= Mask(params, pos);
        }
    }

    return nVersion;
}

void VersionBitsCache::Clear()
{
    LOCK(m_mutex);
    for (unsigned int d = 0; d < Consensus::MAX_VERSION_BITS_DEPLOYMENTS; d++) {
        m_caches[d].clear();
    }
}

Coverage Report

Created: 2024-08-21 05:08

Line	Count	Source (jump to first uncovered line)
1		// Copyright (c) 2016-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		#include <consensus/params.h>
6		#include <util/check.h>
7		#include <versionbits.h>
8
9		ThresholdState AbstractThresholdConditionChecker::GetStateFor(const CBlockIndex* pindexPrev, const Consensus::Params& params, ThresholdConditionCache& cache) const
10	0	{
11	0	int nPeriod = Period(params);
12	0	int nThreshold = Threshold(params);
13	0	int min_activation_height = MinActivationHeight(params);
14	0	int64_t nTimeStart = BeginTime(params);
15	0	int64_t nTimeTimeout = EndTime(params);
16
17		// Check if this deployment is always active.
18	0	if (nTimeStart == Consensus::BIP9Deployment::ALWAYS_ACTIVE) { Branch (18:9): [True: 0, False: 0]
19	0	return ThresholdState::ACTIVE;
20	0	}
21
22		// Check if this deployment is never active.
23	0	if (nTimeStart == Consensus::BIP9Deployment::NEVER_ACTIVE) { Branch (23:9): [True: 0, False: 0]
24	0	return ThresholdState::FAILED;
25	0	}
26
27		// A block's state is always the same as that of the first of its period, so it is computed based on a pindexPrev whose height equals a multiple of nPeriod - 1.
28	0	if (pindexPrev != nullptr) { Branch (28:9): [True: 0, False: 0]
29	0	pindexPrev = pindexPrev->GetAncestor(pindexPrev->nHeight - ((pindexPrev->nHeight + 1) % nPeriod));
30	0	}
31
32		// Walk backwards in steps of nPeriod to find a pindexPrev whose information is known
33	0	std::vector<const CBlockIndex*> vToCompute;
34	0	while (cache.count(pindexPrev) == 0) { Branch (34:12): [True: 0, False: 0]
35	0	if (pindexPrev == nullptr) { Branch (35:13): [True: 0, False: 0]
36		// The genesis block is by definition defined.
37	0	cache[pindexPrev] = ThresholdState::DEFINED;
38	0	break;
39	0	}
40	0	if (pindexPrev->GetMedianTimePast() < nTimeStart) { Branch (40:13): [True: 0, False: 0]
41		// Optimization: don't recompute down further, as we know every earlier block will be before the start time
42	0	cache[pindexPrev] = ThresholdState::DEFINED;
43	0	break;
44	0	}
45	0	vToCompute.push_back(pindexPrev);
46	0	pindexPrev = pindexPrev->GetAncestor(pindexPrev->nHeight - nPeriod);
47	0	}
48
49		// At this point, cache[pindexPrev] is known
50	0	assert(cache.count(pindexPrev));
51	0	ThresholdState state = cache[pindexPrev];
52
53		// Now walk forward and compute the state of descendants of pindexPrev
54	0	while (!vToCompute.empty()) { Branch (54:12): [True: 0, False: 0]
55	0	ThresholdState stateNext = state;
56	0	pindexPrev = vToCompute.back();
57	0	vToCompute.pop_back();
58
59	0	switch (state) { Branch (59:17): [True: 0, False: 0]
60	0	case ThresholdState::DEFINED: { Branch (60:13): [True: 0, False: 0]
61	0	if (pindexPrev->GetMedianTimePast() >= nTimeStart) { Branch (61:21): [True: 0, False: 0]
62	0	stateNext = ThresholdState::STARTED;
63	0	}
64	0	break;
65	0	}
66	0	case ThresholdState::STARTED: { Branch (66:13): [True: 0, False: 0]
67		// We need to count
68	0	const CBlockIndex* pindexCount = pindexPrev;
69	0	int count = 0;
70	0	for (int i = 0; i < nPeriod; i++) { Branch (70:33): [True: 0, False: 0]
71	0	if (Condition(pindexCount, params)) { Branch (71:25): [True: 0, False: 0]
72	0	count++;
73	0	}
74	0	pindexCount = pindexCount->pprev;
75	0	}
76	0	if (count >= nThreshold) { Branch (76:21): [True: 0, False: 0]
77	0	stateNext = ThresholdState::LOCKED_IN;
78	0	} else if (pindexPrev->GetMedianTimePast() >= nTimeTimeout) { Branch (78:28): [True: 0, False: 0]
79	0	stateNext = ThresholdState::FAILED;
80	0	}
81	0	break;
82	0	}
83	0	case ThresholdState::LOCKED_IN: { Branch (83:13): [True: 0, False: 0]
84		// Progresses into ACTIVE provided activation height will have been reached.
85	0	if (pindexPrev->nHeight + 1 >= min_activation_height) { Branch (85:21): [True: 0, False: 0]
86	0	stateNext = ThresholdState::ACTIVE;
87	0	}
88	0	break;
89	0	}
90	0	case ThresholdState::FAILED: Branch (90:13): [True: 0, False: 0]
91	0	case ThresholdState::ACTIVE: { Branch (91:13): [True: 0, False: 0]
92		// Nothing happens, these are terminal states.
93	0	break;
94	0	}
95	0	}
96	0	cache[pindexPrev] = state = stateNext;
97	0	}
98
99	0	return state;
100	0	}
101
102		BIP9Stats AbstractThresholdConditionChecker::GetStateStatisticsFor(const CBlockIndex* pindex, const Consensus::Params& params, std::vector<bool>* signalling_blocks) const
103	0	{
104	0	BIP9Stats stats = {};
105
106	0	stats.period = Period(params);
107	0	stats.threshold = Threshold(params);
108
109	0	if (pindex == nullptr) return stats; Branch (109:9): [True: 0, False: 0]
110
111		// Find how many blocks are in the current period
112	0	int blocks_in_period = 1 + (pindex->nHeight % stats.period);
113
114		// Reset signalling_blocks
115	0	if (signalling_blocks) { Branch (115:9): [True: 0, False: 0]
116	0	signalling_blocks->assign(blocks_in_period, false);
117	0	}
118
119		// Count from current block to beginning of period
120	0	int elapsed = 0;
121	0	int count = 0;
122	0	const CBlockIndex* currentIndex = pindex;
123	0	do {
124	0	++elapsed;
125	0	--blocks_in_period;
126	0	if (Condition(currentIndex, params)) { Branch (126:13): [True: 0, False: 0]
127	0	++count;
128	0	if (signalling_blocks) signalling_blocks->at(blocks_in_period) = true; Branch (128:17): [True: 0, False: 0]
129	0	}
130	0	currentIndex = currentIndex->pprev;
131	0	} while(blocks_in_period > 0); Branch (131:13): [True: 0, False: 0]
132
133	0	stats.elapsed = elapsed;
134	0	stats.count = count;
135	0	stats.possible = (stats.period - stats.threshold ) >= (stats.elapsed - count);
136
137	0	return stats;
138	0	}
139
140		int AbstractThresholdConditionChecker::GetStateSinceHeightFor(const CBlockIndex* pindexPrev, const Consensus::Params& params, ThresholdConditionCache& cache) const
141	0	{
142	0	int64_t start_time = BeginTime(params);
143	0	if (start_time == Consensus::BIP9Deployment::ALWAYS_ACTIVE \|\| start_time == Consensus::BIP9Deployment::NEVER_ACTIVE) { Branch (143:9): [True: 0, False: 0] Branch (143:67): [True: 0, False: 0]
144	0	return 0;
145	0	}
146
147	0	const ThresholdState initialState = GetStateFor(pindexPrev, params, cache);
148
149		// BIP 9 about state DEFINED: "The genesis block is by definition in this state for each deployment."
150	0	if (initialState == ThresholdState::DEFINED) { Branch (150:9): [True: 0, False: 0]
151	0	return 0;
152	0	}
153
154	0	const int nPeriod = Period(params);
155
156		// A block's state is always the same as that of the first of its period, so it is computed based on a pindexPrev whose height equals a multiple of nPeriod - 1.
157		// To ease understanding of the following height calculation, it helps to remember that
158		// right now pindexPrev points to the block prior to the block that we are computing for, thus:
159		// if we are computing for the last block of a period, then pindexPrev points to the second to last block of the period, and
160		// if we are computing for the first block of a period, then pindexPrev points to the last block of the previous period.
161		// The parent of the genesis block is represented by nullptr.
162	0	pindexPrev = Assert(pindexPrev->GetAncestor(pindexPrev->nHeight - ((pindexPrev->nHeight + 1) % nPeriod)));
163
164	0	const CBlockIndex* previousPeriodParent = pindexPrev->GetAncestor(pindexPrev->nHeight - nPeriod);
165
166	0	while (previousPeriodParent != nullptr && GetStateFor(previousPeriodParent, params, cache) == initialState) { Branch (166:12): [True: 0, False: 0] Branch (166:47): [True: 0, False: 0]
167	0	pindexPrev = previousPeriodParent;
168	0	previousPeriodParent = pindexPrev->GetAncestor(pindexPrev->nHeight - nPeriod);
169	0	}
170
171		// Adjust the result because right now we point to the parent block.
172	0	return pindexPrev->nHeight + 1;
173	0	}
174
175		namespace
176		{
177		/**
178		* Class to implement versionbits logic.
179		*/
180		class VersionBitsConditionChecker : public AbstractThresholdConditionChecker {
181		private:
182		const Consensus::DeploymentPos id;
183
184		protected:
185	0	int64_t BeginTime(const Consensus::Params& params) const override { return params.vDeployments[id].nStartTime; }
186	0	int64_t EndTime(const Consensus::Params& params) const override { return params.vDeployments[id].nTimeout; }
187	0	int MinActivationHeight(const Consensus::Params& params) const override { return params.vDeployments[id].min_activation_height; }
188	0	int Period(const Consensus::Params& params) const override { return params.nMinerConfirmationWindow; }
189	0	int Threshold(const Consensus::Params& params) const override { return params.nRuleChangeActivationThreshold; }
190
191		bool Condition(const CBlockIndex* pindex, const Consensus::Params& params) const override
192	0	{
193	0	return (((pindex->nVersion & VERSIONBITS_TOP_MASK) == VERSIONBITS_TOP_BITS) && (pindex->nVersion & Mask(params)) != 0); Branch (193:17): [True: 0, False: 0] Branch (193:88): [True: 0, False: 0]
194	0	}
195
196		public:
197	0	explicit VersionBitsConditionChecker(Consensus::DeploymentPos id_) : id(id_) {}
198	0	uint32_t Mask(const Consensus::Params& params) const { return (uint32_t{1}) << params.vDeployments[id].bit; }
199		};
200
201		} // namespace
202
203		ThresholdState VersionBitsCache::State(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::DeploymentPos pos)
204	0	{
205	0	LOCK(m_mutex);
206	0	return VersionBitsConditionChecker(pos).GetStateFor(pindexPrev, params, m_caches[pos]);
207	0	}
208
209		BIP9Stats VersionBitsCache::Statistics(const CBlockIndex* pindex, const Consensus::Params& params, Consensus::DeploymentPos pos, std::vector<bool>* signalling_blocks)
210	0	{
211	0	return VersionBitsConditionChecker(pos).GetStateStatisticsFor(pindex, params, signalling_blocks);
212	0	}
213
214		int VersionBitsCache::StateSinceHeight(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::DeploymentPos pos)
215	0	{
216	0	LOCK(m_mutex);
217	0	return VersionBitsConditionChecker(pos).GetStateSinceHeightFor(pindexPrev, params, m_caches[pos]);
218	0	}
219
220		uint32_t VersionBitsCache::Mask(const Consensus::Params& params, Consensus::DeploymentPos pos)
221	0	{
222	0	return VersionBitsConditionChecker(pos).Mask(params);
223	0	}
224
225		int32_t VersionBitsCache::ComputeBlockVersion(const CBlockIndex* pindexPrev, const Consensus::Params& params)
226	0	{
227	0	LOCK(m_mutex);
228	0	int32_t nVersion = VERSIONBITS_TOP_BITS;
229
230	0	for (int i = 0; i < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; i++) { Branch (230:21): [True: 0, False: 0]
231	0	Consensus::DeploymentPos pos = static_cast<Consensus::DeploymentPos>(i);
232	0	ThresholdState state = VersionBitsConditionChecker(pos).GetStateFor(pindexPrev, params, m_caches[pos]);
233	0	if (state == ThresholdState::LOCKED_IN \|\| state == ThresholdState::STARTED) { Branch (233:13): [True: 0, False: 0] Branch (233:51): [True: 0, False: 0]
234	0	nVersion \|= Mask(params, pos);
235	0	}
236	0	}
237
238	0	return nVersion;
239	0	}
240
241		void VersionBitsCache::Clear()
242	1	{
243	1	LOCK(m_mutex);
244	3	for (unsigned int d = 0; d < Consensus::MAX_VERSION_BITS_DEPLOYMENTS; d++) { Branch (244:30): [True: 2, False: 1]
245	2	m_caches[d].clear();
246	2	}
247	1	}