Blocklore
Esc

Type to search every published claim: statements, sources and topics.

Enter opens the claim; with no match, suggests the questionUp and down to move
976,842
Reading as Holder. What matters when you hold your own coins.6 of 26 claims
How deep to read

What it isCurious

Bitcoin mining costs real resources: the Bitcoin whitepaper compares issuing new coins through mining to gold miners spending resources, and names computer time and electricity as what Bitcoin miners spend.1: open 2 sources
FactCuriousEstablishedMedium confidence
In our case, it is CPU time and electricity that is expended.
Section 6, Incentive, first paragraph, read 2026-11-20
is analogous to gold miners expending resources to add gold to circulation.
Section 6, Incentive, first paragraph, read 2026-11-20
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 2/2History, hash and citation
Bitcoin aims for one block about every 10 minutes on average: the network adjusts how hard mining is so that, as more or less computing power joins, blocks keep arriving at roughly that rate.2: open 2 sources
FactCuriousEstablishedHigh confidence
consensus.nPowTargetSpacing = 10 * 60;
CMainParams, consensus.nPowTargetSpacing, read 2026-11-20
the proof-of-work difficulty is determined by a moving average targeting an average number of blocks per hour.
Section 4, Proof-of-Work, last paragraph, read 2026-11-20
bitcoin/bitcoin at f498a5a671 contains this text in src/kernel/chainparams.cpp, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/kernel/chainparams.cpp | grep -nF 'consensus.nPowTargetSpacing = 10 * 60;'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 2/2, code 1/1History, hash and citation

Why block times varyUser

A 2018 statistical study of Bitcoin block arrival data (arXiv:1801.07447) reported that block arrivals do not follow the homogeneous Poisson process it says the original Bitcoin paper suggested, and proposed a refined model covering both periods of constant difficulty and how difficulty changes over time.3: open 3 sources
FactResearcherEstablishedMedium confidence
Based on blockchain block arrival data and stochastic analysis of the block arrival process, we demonstrate that this is not the case.
Abstract, read 2026-11-20
In the original Bitcoin paper, it was suggested that the blockchain arrivals occur according to a homogeneous Poisson process.
Abstract, read 2026-11-20
We present a refined mathematical model for block arrivals, focusing on both the block arrivals during a period of constant difficulty and how the difficulty level evolves over time.
Abstract, read 2026-11-20
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 3/3History, hash and citation
Bitcoin's mainnet difficulty can change only at every 2,016th block, so when total mining power rises or falls between adjustments, blocks arrive faster or slower than 10 minutes on average until the next adjustment.4: open 1 source
How it worksUserEstablishedHigh confidence
T1Bitcoin Core src/pow.cpp, GetNextWorkRequiredSource code, says this directly
// Only change once per difficulty adjustment interval
GetNextWorkRequired, read 2026-11-20
bitcoin/bitcoin at f498a5a671 contains this text in src/pow.cpp, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/pow.cpp | grep -nF '// Only change once per difficulty adjustment interval'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 1/1, code 1/1History, hash and citation

Work decides the chainHolder

Bitcoin nodes follow the valid chain with the most accumulated proof of work, not the chain with the most blocks: Bitcoin Core ranks candidate chain tips first by total chain work, so a shorter chain of harder blocks can outrank a longer chain of easier ones.5: open 3 sources
How it worksHolderEstablishedHigh confidence
if (pa->nChainWork > pb->nChainWork) return false;
CBlockIndexWorkComparator::operator(), read 2026-11-20
T1Bitcoin Core src/chain.h, CBlockIndex::nChainWorkSource code, says this directly
Total amount of work (expected number of hashes) in the chain up to and including this block
CBlockIndex, nChainWork member comment, read 2026-11-20
The majority decision is represented by the longest chain, which has the greatest proof-of-work effort invested in it.
Section 4, Proof-of-Work, third paragraph, read 2026-11-20
bitcoin/bitcoin at f498a5a671 contains this text in src/node/blockstorage.cpp, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/node/blockstorage.cpp | grep -nF 'if (pa->nChainWork > pb->nChainWork) return false;'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 3/3, code 1/1History, hash and citation
Each block mined on top of a Bitcoin transaction adds work that anyone trying to reverse it must redo: the Bitcoin whitepaper says an attacker would have to redo the proof of work of that block and every later block, then overtake the honest chain.6: open 1 source
How it worksHolderEstablishedMedium confidence
To modify a past block, an attacker would have to redo the proof-of-work of the block and all blocks after it and then catch up with and surpass the work of the honest nodes.
Section 4, Proof-of-Work, third paragraph, read 2026-11-20
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 1/1History, hash and citation
Bitcoin Core's mainnet parameters set nMinimumChainWork, a minimum total chain work documented in the code with the comment that the best chain should have at least this much work; at commit f498a5a6 its mainnet value is 0x145ec036acc5ba740052af1a0.7: open 2 sources
FactBuilderEstablishedHigh confidence
/** The best chain should have at least this much work */
Consensus::Params, nMinimumChainWork comment, read 2026-11-20
consensus.nMinimumChainWork = uint256{"000000000000000000000000000000000000000145ec036acc5ba740052af1a0"};
CMainParams, consensus.nMinimumChainWork, read 2026-11-20
bitcoin/bitcoin at f498a5a671 contains this text in src/kernel/chainparams.cpp.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/kernel/chainparams.cpp | grep -nF 'consensus.nMinimumChainWork = uint256{"000000000000000000000000000000000000000145ec036acc5ba740052af1a0"};'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 2/2, code 1/1History, hash and citation

The header, the hash and the targetBuilder

A Bitcoin block header is 80 bytes: Bitcoin Core serializes six fields, nVersion (4 bytes), hashPrevBlock (32 bytes), hashMerkleRoot (32 bytes), nTime (4 bytes), nBits (4 bytes) and nNonce (4 bytes), and proof of work is computed over these 80 bytes only.8: open 2 sources
FactBuilderEstablishedHigh confidence
READWRITE(obj.nVersion, obj.hashPrevBlock, obj.hashMerkleRoot, obj.nTime, obj.nBits, obj.nNonce);
CBlockHeader, SERIALIZE_METHODS, read 2026-11-20
A block header with no transactions would be about 80 bytes.
Section 7, Reclaiming Disk Space, last paragraph, read 2026-11-20
bitcoin/bitcoin at f498a5a671 contains this text in src/primitives/block.h, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/primitives/block.h | grep -nF 'READWRITE(obj.nVersion, obj.hashPrevBlock, obj.hashMerkleRoot, obj.nTime, obj.nBits, obj.nNonce);'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 2/2, code 1/1History, hash and citation
A Bitcoin block's hash is the double SHA-256 (SHA-256 applied twice) of its serialized header: Bitcoin Core's CBlockHeader::GetHash writes the header into a HashWriter, whose GetHash computes double SHA-256.9: open 2 sources
TraceBuilderEstablishedHigh confidence
return (HashWriter{} << *this).GetHash();
CBlockHeader::GetHash, read 2026-11-20
T1Bitcoin Core src/hash.h, HashWriter::GetHashSource code, says this directly
Compute the double-SHA256 hash of all data written to this object.
HashWriter::GetHash comment, read 2026-11-20
bitcoin/bitcoin at f498a5a671 contains this text in src/primitives/block.cpp.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/primitives/block.cpp | grep -nF 'return (HashWriter{} << *this).GetHash();'
bitcoin/bitcoin at f498a5a671 contains this text in src/hash.h.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/hash.h | grep -nF 'Compute the double-SHA256 hash of all data written to this object.'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 2/2, code 2/2History, hash and citation
A Bitcoin header's 4-byte nBits field encodes the 256-bit target in a compact floating-point-like form: the top byte is an exponent in base 256 and the lower 23 bits are the mantissa, so the target equals mantissa times 256 to the power of (exponent minus 3).10: open 2 sources
How it worksBuilderEstablishedHigh confidence
The most significant 8 bits are the unsigned exponent of base 256.
Comment above arith_uint256::SetCompact, read 2026-11-20
N = (-1^sign) * mantissa * 256^(exponent-3)
Comment above arith_uint256::SetCompact, read 2026-11-20
bitcoin/bitcoin at f498a5a671 contains this text in src/arith_uint256.h.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/arith_uint256.h | grep -nF 'N = (-1^sign) * mantissa * 256^(exponent-3)'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 2/2, code 1/1History, hash and citation
Bitcoin Core's proof-of-work check in src/pow.cpp rejects a block header if the target decoded from its nBits is zero, negative, overflowing or above the network's proof-of-work limit, or if the header hash, read as a 256-bit number, is greater than that target.11: open 2 sources
TraceBuilderEstablishedHigh confidence
T1Bitcoin Core src/pow.cpp, CheckProofOfWorkImplSource code, says this directly
if (UintToArith256(hash) > bnTarget)
CheckProofOfWorkImpl, read 2026-11-20
T1Bitcoin Core src/pow.cpp, DeriveTargetSource code, says this directly
if (fNegative || bnTarget == 0 || fOverflow || bnTarget > UintToArith256(pow_limit))
DeriveTarget, range check, read 2026-11-20
bitcoin/bitcoin at f498a5a671 contains this text in src/pow.cpp, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/pow.cpp | grep -nF 'if (fNegative || bnTarget == 0 || fOverflow || bnTarget > UintToArith256(pow_limit))'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 2/2, code 1/1History, hash and citation
Bitcoin's genesis block (block 0, timestamp 1231006505, 3 January 2009) has nBits 0x1d00ffff, the compact form of mainnet's easiest permitted target, which corresponds to difficulty 1.12: open 3 sources
FactBuilderEstablishedHigh confidence
genesis = CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1, 50 * COIN);
CMainParams, CreateGenesisBlock call, read 2026-11-20
consensus.powLimit = uint256{"00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"};
CMainParams, consensus.powLimit, read 2026-11-20
T1Block 0 on mempool.spaceThe chain, says this directly
Block 0 header, bits and difficulty, read 2026-11-20
Block 0 has hash 000000000019d668...
Run it yourselfbitcoin-cli getblockhash 0
Block 0's header has bits = 1d00ffff.
Run it yourselfbitcoin-cli getblockheader $(bitcoin-cli getblockhash 0) | grep '"bits"'
Block 0's header has time = 1231006505.
Run it yourselfbitcoin-cli getblockheader $(bitcoin-cli getblockhash 0) | grep '"time"'
bitcoin/bitcoin at f498a5a671 contains this text in src/kernel/chainparams.cpp, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/kernel/chainparams.cpp | grep -nF 'genesis = CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1, 50 * COIN);'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 3/3, code 1/1, chain 3/3 (esplora pair agreed)History, hash and citation

Difficulty adjustmentBuilder

Bitcoin mainnet recalculates its proof-of-work target every 2,016 blocks: Bitcoin Core derives this interval as the target timespan of two weeks (1,209,600 seconds) divided by the target block spacing of 600 seconds.13: open 3 sources
How it worksBuilderEstablishedHigh confidence
int64_t DifficultyAdjustmentInterval() const { return nPowTargetTimespan / nPowTargetSpacing; }
Consensus::Params::DifficultyAdjustmentInterval, read 2026-11-20
consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
CMainParams, consensus.nPowTargetTimespan, read 2026-11-20
The difficulty of the computational problem is updated every 2,016 blocks in order to control the rate at which blocks are generated.
Abstract, read 2026-11-20
bitcoin/bitcoin at f498a5a671 contains this text in src/kernel/chainparams.cpp, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/kernel/chainparams.cpp | grep -nF 'consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks'
bitcoin/bitcoin at f498a5a671 contains this text in src/consensus/params.h, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/consensus/params.h | grep -nF 'int64_t DifficultyAdjustmentInterval() const { return nPowTargetTimespan / nPowTargetSpacing; }'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 3/3, code 2/2History, hash and citation
At each mainnet retarget, Bitcoin Core's CalculateNextWorkRequired multiplies the previous target by the period's measured timespan, first limited to between one quarter and four times two weeks, divides by the two-week target timespan, and caps the result at the proof-of-work limit, so faster periods make the target smaller and mining harder.14: open 3 sources
TraceBuilderEstablishedHigh confidence
bnNew *= nActualTimespan;
CalculateNextWorkRequired, Retarget, read 2026-11-20
bnNew /= params.nPowTargetTimespan;
CalculateNextWorkRequired, division and cap, read 2026-11-20
if (nActualTimespan < params.nPowTargetTimespan/4)
CalculateNextWorkRequired, Limit adjustment step, read 2026-11-20
bitcoin/bitcoin at f498a5a671 contains this text in src/pow.cpp, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/pow.cpp | grep -nF 'bnNew *= nActualTimespan;'
bitcoin/bitcoin at f498a5a671 contains this text in src/pow.cpp, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/pow.cpp | grep -nF 'bnNew /= params.nPowTargetTimespan;'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 3/3, code 2/2History, hash and citation
Bitcoin limits each difficulty adjustment to a factor of four: Bitcoin Core clamps the measured timespan of a 2,016-block period to between one quarter and four times the two-week target before retargeting, so one retarget can at most quadruple or quarter the target.15: open 2 sources
How it worksBuilderEstablishedHigh confidence
if (nActualTimespan < params.nPowTargetTimespan/4)
CalculateNextWorkRequired, Limit adjustment step, read 2026-11-20
nActualTimespan = params.nPowTargetTimespan*4;
CalculateNextWorkRequired, Limit adjustment step, read 2026-11-20
bitcoin/bitcoin at f498a5a671 contains this text in src/pow.cpp, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/pow.cpp | grep -nF 'if (nActualTimespan < params.nPowTargetTimespan/4)'
bitcoin/bitcoin at f498a5a671 contains this text in src/pow.cpp, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/pow.cpp | grep -nF 'if (nActualTimespan > params.nPowTargetTimespan*4)'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 2/2, code 2/2History, hash and citation
Bitcoin nodes do not let miners pick their own difficulty: Bitcoin Core's ContextualCheckBlockHeader rejects a header as "bad-diffbits" unless its nBits equals the value GetNextWorkRequired computes from the preceding chain.16: open 1 source
TraceBuilderEstablishedHigh confidence
if (block.nBits != GetNextWorkRequired(pindexPrev, &block, consensusParams))
ContextualCheckBlockHeader, proof-of-work check, read 2026-11-20
bitcoin/bitcoin at f498a5a671 contains this text in src/validation.cpp, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/validation.cpp | grep -nF 'if (block.nBits != GetNextWorkRequired(pindexPrev, &block, consensusParams))'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 1/1, code 1/1History, hash and citation
At the retarget at block 32,256, mined on 30 December 2009, Bitcoin's nBits changed from 0x1d00ffff (block 32,255) to 0x1d00d86a, raising mining difficulty from 1 to about 1.18.17: open 2 sources
EventBuilderEstablishedHigh confidence
T1Block 32,256 on mempool.spaceThe chain, says this directly
Block 32,256 header, bits 486594666 (0x1d00d86a), timestamp 1262153464, difficulty 1.1828995343128408, read 2026-11-20
T1Block 32,255 on mempool.spaceThe chain, says this directly
Block 32,255 header, bits 486604799 (0x1d00ffff), difficulty 1.0, read 2026-11-20
Block 32,256 has hash 000000004f2886a1...
Run it yourselfbitcoin-cli getblockhash 32256
Block 32,256's header has bits = 1d00d86a.
Run it yourselfbitcoin-cli getblockheader $(bitcoin-cli getblockhash 32256) | grep '"bits"'
Block 32,256's header has time = 1262153464.
Run it yourselfbitcoin-cli getblockheader $(bitcoin-cli getblockhash 32256) | grep '"time"'
Block 32,255 has hash 00000000984f9621...
Run it yourselfbitcoin-cli getblockhash 32255
Block 32,255's header has bits = 1d00ffff.
Run it yourselfbitcoin-cli getblockheader $(bitcoin-cli getblockhash 32255) | grep '"bits"'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 2/2, chain 5/5 (esplora pair agreed)History, hash and citation

Timestamps and chainworkBuilder

Bitcoin Core rejects a block whose timestamp is not later than the median time past, which is the median of the timestamps of the previous 11 blocks, ending with the new block's parent.18: open 2 sources
How it worksBuilderEstablishedHigh confidence
static constexpr int nMedianTimeSpan = 11;
nMedianTimeSpan and GetMedianTimePast, read 2026-11-20
if (block.GetBlockTime() <= pindexPrev->GetMedianTimePast())
ContextualCheckBlockHeader, time-too-old check, read 2026-11-20
bitcoin/bitcoin at f498a5a671 contains this text in src/chain.h, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/chain.h | grep -nF 'static constexpr int nMedianTimeSpan = 11;'
bitcoin/bitcoin at f498a5a671 contains this text in src/validation.cpp, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/validation.cpp | grep -nF 'if (block.GetBlockTime() <= pindexPrev->GetMedianTimePast())'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 2/2, code 2/2History, hash and citation
Bitcoin Core counts each block's work as 2 to the power 256 divided by (target plus 1), the expected number of hashes needed to meet that target, and sums these values along a chain into nChainWork, the chainwork figure that decides which chain is best.19: open 2 sources
TraceBuilderEstablishedHigh confidence
T1Bitcoin Core src/chain.cpp, GetBitsProofSource code, says this directly
// We need to compute 2**256 / (bnTarget+1), but we can't represent 2**256
GetBitsProof comment, read 2026-11-20
T1Bitcoin Core src/chain.h, CBlockIndex::nChainWorkSource code, says this directly
Total amount of work (expected number of hashes) in the chain up to and including this block
CBlockIndex, nChainWork member comment, read 2026-11-20
bitcoin/bitcoin at f498a5a671 contains this text in src/chain.cpp, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/chain.cpp | grep -nF 'return (~bnTarget / (bnTarget + 1)) + 1;'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 2/2, code 1/1History, hash and citation

The timewarp bug and its fixesResearcher

Bitcoin Core measures each 2,016-block difficulty period from the timestamp of its own first block to that of its last block, which spans 2,015 block intervals rather than 2,016, so consecutive measurement windows do not overlap. This off-by-one is the property the timewarp attack exploits.20: open 3 sources
How it worksResearcherEstablishedHigh confidence
T1Bitcoin Core src/pow.cpp, GetNextWorkRequiredSource code, says this directly
int nHeightFirst = pindexLast->nHeight - (params.DifficultyAdjustmentInterval()-1);
GetNextWorkRequired, choice of first block, read 2026-11-20
The timewarp vulnerability exploits how difficulty adjustment periods don't overlap.
Post 1, timewarp section, published 2024-03-24, read 2026-11-20
T2Bitcoin Optech Newsletter, 24 April 2024Bitcoin Optech, supports part of it
explains the off-by-one error in Bitcoin’s difficulty retargeting calculation
Selected Q&A from Bitcoin Stack Exchange, Where exactly is the off-by-one difficulty bug?, read 2026-11-20
bitcoin/bitcoin at f498a5a671 contains this text in src/pow.cpp, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/pow.cpp | grep -nF 'int nHeightFirst = pindexLast->nHeight - (params.DifficultyAdjustmentInterval()-1);'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 3/3, code 1/1History, hash and citation
BIP 54 (Consensus Cleanup) states that the timewarp bug lets an attacker with a majority of Bitcoin's hashrate arbitrarily lower mining difficulty by manipulating block timestamps, and that in the worst case the attacker can bring difficulty to its minimum within 38 days.21: open 4 sources
FactResearcherEstablishedHigh confidence
T1BIP 54, Consensus CleanupBIP, says this directly
makes it possible for a majority-hashrate attacker to arbitrarily lower mining difficulty
Motivation, read 2026-11-20
T1BIP 54, Consensus CleanupBIP, says this directly
In the worst case, an attacker can bring down the difficulty to its minimum within 38 days of starting the attack.
Motivation, read 2026-11-20
T1Great Consensus Cleanup Revival (Delving Bitcoin, post 1)Delving Bitcoin, supports part of it
setting the timestamp of the last block in a retarget period as much in the future as possible (now + 2h)
Post 1, timewarp section, published 2024-03-24, read 2026-11-20
T2Bitcoin Optech topic, Time warpBitcoin Optech, supports part of it
Time warp is an exploit of Bitcoin’s difficulty adjustment algorithm that allows miners controlling a large amount
Topic summary, first paragraph, read 2026-11-20
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 4/4History, hash and citation
BIP 54 proposes that the first block of each 2,016-block difficulty period (height divisible by 2,016) must have a timestamp no earlier than 7,200 seconds (two hours) before the timestamp of the block immediately preceding it, which the BIP gives as its fix for the timewarp attack.22: open 2 sources
FactResearcherEstablishedHigh confidence
T1BIP 54, Consensus CleanupBIP, says this directly
The former is fixed by preventing the timestamp of the first block of a difficulty period from being lower than the previous block's, with a two-hour grace period.
Rationale, read 2026-11-20
permits a majority hashrate attacker to arbitrarily increase block cadence.
Topic summary, time warp, read 2026-11-20
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 2/2History, hash and citation
As of 20 November 2026, Bitcoin Core PR #35793, "Implement BIP 54 (Consensus Cleanup) without mainnet activation", is open and not merged; its description says the BIP 54 validation rules it implements are only enabled on regtest, with mainnet activation, if any, to be considered separately.23: open 2 sources
FactResearcherEstablishedMedium confidence
This implements the Consensus Cleanup validation rules proposed in BIP 54
PR description and state (open), read 2026-11-20
These rules are only enabled on regtest. Mainnet activation, if any, is to be considered separately.
PR description, first paragraph, read 2026-11-20
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 2/2History, hash and citation
BIP 94 (Testnet 4) adds a timewarp rule: the first block of each difficulty period must not be timestamped more than 600 seconds before the previous block. Bitcoin Core enforces this rule only on testnet4 and regtest; its mainnet parameters set enforce_BIP94 to false.24: open 5 sources
FactResearcherEstablishedHigh confidence
T1BIP 94, Testnet 4BIP, says this directly
of the immediately prior block minus 600 seconds
Specification, consensus rules, rule 1, read 2026-11-20
inline constexpr int64_t MAX_TIMEWARP = 600;
MAX_TIMEWARP, read 2026-11-20
// Testnet4 and regtest only: Check timestamp against prev for difficulty-adjustment
ContextualCheckBlockHeader, BIP94 timewarp check, read 2026-11-20
consensus.enforce_BIP94 = false;
CMainParams, consensus.enforce_BIP94, read 2026-11-20
a fix to the difficulty adjustment mechanism, which was part of the motivation that started the discussion.
PR description, read 2026-11-20
bitcoin/bitcoin at f498a5a671 contains this text in src/consensus/consensus.h, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/consensus/consensus.h | grep -nF 'inline constexpr int64_t MAX_TIMEWARP = 600;'
bitcoin/bitcoin at f498a5a671 contains this text in src/validation.cpp.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/validation.cpp | grep -nF 'if (block.GetBlockTime() < pindexPrev->GetBlockTime() - MAX_TIMEWARP) {'
BIP 94's Status is "Deployed" on the default branch.
Run it yourselfcurl -s https://raw.githubusercontent.com/bitcoin/bips/master/bip-0094.mediawiki | grep -m1 -E '^ *Statuss?:'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 5/5, code 3/3History, hash and citation
At commit f498a5a6, Bitcoin Core's GetMinimumTime raises the minimum block template timestamp on all networks to respect both the BIP 94 600-second timewarp limit and the BIP 54 rule that a period's last block is not earlier than its first; the BIP 54 part came from Bitcoin Core PR #35949, merged 7 September 2026.25: open 4 sources
TraceResearcherEstablishedHigh confidence
T1Bitcoin Core src/node/miner.cpp, GetMinimumTimeSource code, says this directly
min_time = std::max<int64_t>(min_time, pindexPrev->GetBlockTime() - MAX_TIMEWARP);
GetMinimumTime, read 2026-11-20
T1Bitcoin Core src/node/miner.cpp, GetMinimumTimeSource code, says this directly
min_time = std::max<int64_t>(min_time, first_block->GetBlockTime());
GetMinimumTime, BIP54 Murch-Zawy rule, read 2026-11-20
This makes the miner enforce the murch-zawy rule for which #35793 adds the validation part.
PR description, read 2026-11-20
T2Bitcoin Optech Newsletter, 11 September 2026Bitcoin Optech, supports part of it
updates block template creation to follow BIP54’s proposed mitigation for the
Notable code and documentation changes, Bitcoin Core, read 2026-11-20
bitcoin/bitcoin at f498a5a671 contains this text in src/node/miner.cpp, and still does on the default branch.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/node/miner.cpp | grep -nF 'min_time = std::max<int64_t>(min_time, first_block->GetBlockTime());'
bitcoin/bitcoin at f498a5a671 contains this text in src/node/miner.cpp.
Run it yourselfgit clone https://github.com/bitcoin/bitcoin && git -C bitcoin show f498a5a6718d9157b6afb85412c3462439117702:src/node/miner.cpp | grep -nF '// Account for BIP94 timewarp rule on all networks. This makes future'
Checked at block 976,753, 20 Nov 2026, 16:42 UTC: quotes 4/4, code 2/2History, hash and citation