




<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>Bitcoin News, Price &amp; Analysis &#8211; BBVN Markets</title>
	<atom:link href="https://www.newsbbvn.com/crypto/bitcoin/feed" rel="self" type="application/rss+xml" />
	<link>https://www.newsbbvn.com</link>
	<description>Live Crypto Prices &#38; Market Rankings in Vietnam</description>
	<lastBuildDate>Wed, 04 Nov 2026 16:43:14 +0000</lastBuildDate>
	<language>en-US</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1.4</generator>

<image>
	<url>https://www.newsbbvn.com/wp-content/uploads/2024/06/cropped-2024063005241379-32x32.png</url>
	<title>Bitcoin News, Price &amp; Analysis &#8211; BBVN Markets</title>
	<link>https://www.newsbbvn.com</link>
	<width>32</width>
	<height>32</height>
</image> 
	<item>
		<title>Your Transaction Is Stuck. RBF and CPFP Are Not the Same Repair.</title>
		<link>https://www.newsbbvn.com/crypto/bitcoin/1068.html</link>
					<comments>https://www.newsbbvn.com/crypto/bitcoin/1068.html#respond</comments>
		
		<dc:creator><![CDATA[BBVN Research]]></dc:creator>
		<pubDate>Wed, 04 Nov 2026 16:43:14 +0000</pubDate>
				<category><![CDATA[Bitcoin]]></category>
		<category><![CDATA[bitcoin]]></category>
		<category><![CDATA[crypto]]></category>
		<guid isPermaLink="false">https://www.newsbbvn.com/markets/1068.html</guid>

					<description><![CDATA[A stuck transaction is not broken; it is losing an auction. Replace-by-fee edits your own transaction, child-pays-for-parent edits the one spending its output, and who holds the keys decides which door is open.]]></description>
										<content:encoded><![CDATA[
<div class="kEbid">
<p class="kE-bid-l"><b>2 sat/vB</b> your bid<span class="kE-bid-x">→</span><mark>38 sat/vB</mark> the clearing rate</p><p class="kE-bid-p">Two satoshis per byte looked fine at 2am. By morning the cheapest seat in a block costs forty. Nothing about the transaction broke: it is valid, signed, and still sitting in most mempools. It is simply losing an auction you did not know you had entered.</p>
</div>



<p class="wp-block-paragraph">I have watched people conclude, at this exact moment, that the network is congested, that the wallet is broken, or that the coins are gone. All three are wrong. The transaction is fine. The bid is not.</p>



<h2 class="wp-block-heading" id="block-space-is-sold-by-the-byte-not-by-the-dollar">Block space is sold by the byte, not by the dollar</h2>



<p class="wp-block-paragraph">The first intuition to unlearn is that a bigger payment deserves priority. A block is not a queue sorted by value. It is a container with a byte budget, and the only price that matters is satoshis per virtual byte.</p>



<p class="wp-block-paragraph">A transfer of forty thousand dollars in one input and two outputs occupies about 141 virtual bytes. A transfer of forty dollars in the same shape occupies the same 141 virtual bytes. A miner earns the same from both at the same feerate, so it has no reason to prefer either. This is why &#8220;but I moved a lot of money&#8221; is not an argument you can make to the network. The network does not know what the money is for. It knows how many bytes you are asking to occupy.</p>



<p class="wp-block-paragraph">The number that matters is not your feerate in isolation. It is the <strong>clearing rate</strong> — the marginal rate at which the next block fills. If demand for that space doubles, the clearing rate can move by a factor of twenty inside a day. Your 2 sat/vB was a reasonable bid when you made it. Overnight it stopped being one.</p>



<figure class="wp-block-image size-large"><img fetchpriority="high" decoding="async" width="1600" height="1028" src="https://www.newsbbvn.com/wp-content/uploads/2026/11/fb-1.jpg" alt="An auction room: block space is sold to whoever bids highest, not whoever needs it most" class="wp-image-1059"/><figcaption class="wp-element-caption">Sven Ruediger, CC BY 3.0, via Wikimedia Commons</figcaption></figure>



<p class="wp-block-paragraph">There is a second thing worth internalising before the repair options make sense: <strong>nobody can cancel a transaction.</strong> Not you, not your wallet, not an exchange. A signed transaction is a valid fact about the UTXO set waiting to be recorded. The only way to remove it is to make it irrelevant — to get a <em>different</em> transaction confirmed that spends the same coins. Every technique below is a version of that one idea.</p>



<h2 class="wp-block-heading" id="who-holds-the-keys-decides-which-door-is-open">Who holds the keys decides which door is open</h2>



<p class="wp-block-paragraph">This is the part almost every &#8220;how to speed up a stuck transaction&#8221; guide skips, and it is the only part that matters when you are the one waiting.</p>



<p class="wp-block-paragraph">If you sent from your own wallet, you hold the private keys to the inputs. You can build a new transaction that spends the same coins and pays more. That is replace-by-fee.</p>



<p class="wp-block-paragraph">If the transaction came from an exchange withdrawal, you do not hold those keys. The exchange built the transaction, the exchange signed it, and only the exchange can replace it. Support desks usually will not, because that withdrawal is one line in a batched transaction serving dozens of customers. You have exactly one lever, and it operates from the receiving side: child-pays-for-parent.</p>



<p class="wp-block-paragraph">So the question &#8220;should I use RBF or CPFP&#8221; is really the question &#8220;am I the sender or the recipient&#8221;. Everything else follows.</p>



<h2 class="wp-block-heading" id="door-one-replace-your-own-transaction">Door one: replace your own transaction</h2>



<p class="wp-block-paragraph">Replace-by-fee means rebroadcasting a conflicting transaction that spends at least one of the same inputs, pays a higher fee, and therefore competes for the same slot. Only one of the two can ever confirm. A node accepts the swap only if it satisfies a short list of conditions, and those conditions exist to stop replacement from becoming a free denial-of-service channel:</p>



<div class="kEcards">
<div class="kE-cs"><article class="kE-c"><small>01</small><h5>Higher absolute fee</h5><p>The new transaction must pay more in total than everything it evicts, not merely more per byte.</p></article><article class="kE-c"><small>02</small><h5>Incremental relay fee</h5><p>On top of that it must cover its own relay cost at the node&#8217;s rate, 1 sat/vB by default.</p></article><article class="kE-c"><small>03</small><h5>No new unconfirmed inputs</h5><p>It may not pull in unconfirmed coins the original did not already spend.</p></article><article class="kE-c"><small>04</small><h5>At most 100 evictions</h5><p>It may not clear more than 100 transactions at once, counting descendants.</p></article></div>
</div>



<p class="wp-block-paragraph">Notice that the first rule is about <em>absolute</em> fee, not feerate. This trips people up constantly. If you shrink a 400 vB transaction to 200 vB at a better rate, the total fee can go <strong>down</strong>, and a node will reject the replacement even though the new one looks better per byte. Bumping is never a discount.</p>



<p class="wp-block-paragraph">The signalling story is now history, and most articles have not caught up. Under BIP-125, a sender had to opt in by setting an input&#8217;s <code>nSequence</code> below <code>0xfffffffe</code>, and nodes would refuse to relay replacements for anything that did not flag itself. Merchants leaned on that: an unflagged payment at zero confirmations felt safe. Bitcoin Core 28.0, released in October 2024, changed the default of <code>-mempoolfullrbf</code> from 0 to 1. BIP-125 has since been marked obsolete. Any unconfirmed transaction can now be replaced by a higher-paying version, regardless of how it was built.</p>



<p class="wp-block-paragraph">That was a correction, not a policy shift. Consensus rules always let a miner include whichever conflicting transaction it preferred. The old relay policy created an appearance of safety that miners were never obliged to honour. The honest summary is blunt: <strong>an unconfirmed payment is a proposal, not a settlement.</strong></p>



<pre class="wp-block-code"><code># The wallet rebuilds the transaction, shaving the extra fee off the change output
bitcoin-cli -rpcwallet=mywallet -named bumpfee fee_rate=25
# If the transaction has no change output left, this fails: there is nothing to shave
# and you must add another input instead</code></pre>



<p class="wp-block-paragraph">That last comment is the practical trap. A wallet that sent your entire balance has no change output to reduce, so bumping requires adding a new input — which changes the transaction shape and pulls in another UTXO, possibly another signature. This is why &#8220;keep a change output&#8221; is not just a privacy habit. It is a repair capability.</p>



<h2 class="wp-block-heading" id="door-two-pay-for-it-from-the-other-side">Door two: pay for it from the other side</h2>



<p class="wp-block-paragraph">Child-pays-for-parent works because a child cannot be mined before its parent. A miner that wants the child&#8217;s fee has to take the parent as well, so the two are evaluated together:</p>



<div class="kEbig">
<div class="kE-kp"><h3>20 sat/vB</h3><p>the package rate a parent and child must reach together, not individually</p></div>
</div>



<p class="wp-block-paragraph">The arithmetic is simple and worth doing once by hand. Say the stuck parent is 200 vB paying 2 sat/vB, so 400 satoshis of fee. You want the pair mined at 20 sat/vB and your child transaction is 150 vB. The package needs 20 × (200 + 150) = 7,000 satoshis. The parent already contributes 400, so the child must pay 6,600 — which on its own 150 vB is 44 sat/vB. The child is expensive on purpose. That is the whole mechanism: you are not raising the parent&#8217;s bid, you are bribing the miner to take a package.</p>



<figure class="wp-block-image size-large"><img decoding="async" width="1400" height="1050" src="https://www.newsbbvn.com/wp-content/uploads/2026/11/fb-2.jpg" alt="Taipei traffic in 2005: a queue that clears at the margin, one byte at a time" class="wp-image-1060"/><figcaption class="wp-element-caption">Syced, CC0, via Wikimedia Commons</figcaption></figure>



<p class="wp-block-paragraph">Anyone holding an output of the stuck transaction can do this, which is why it is the recipient&#8217;s only move. It also costs one extra transaction, so it is strictly less efficient than RBF when you have the keys.</p>



<figure class="wp-block-table"><table><thead><tr><th></th><th>Replace-by-fee</th><th>Child-pays-for-parent</th></tr></thead><tbody><tr><td>Who can do it</td><td>whoever signed the original</td><td>anyone holding one of its outputs</td></tr><tr><td>What changes</td><td>the stuck transaction itself</td><td>a new transaction spending its output</td></tr><tr><td>Extra cost</td><td>one replacement, no new transaction</td><td>one extra transaction on chain</td></tr><tr><td>Extra requirement</td><td>a change output to shave, or another input</td><td>an unspent output you control</td></tr><tr><td>Failure mode</td><td>rejected if the absolute fee drops</td><td>child sits behind a parent no miner wants</td></tr></tbody></table></figure>



<h2 class="wp-block-heading" id="what-changed-in-2026-and-why-it-matters-less-than-it-sounds">What changed in 2026, and why it matters less than it sounds</h2>



<p class="wp-block-paragraph">Bitcoin Core 31.0, published on 19 April 2026, rebuilt the mempool around <strong>clusters</strong>: connected sets of related transactions, capped at 64 transactions and 101,000 virtual bytes. Inside a cluster, transactions are ordered by the rate at which the group would realistically be mined, which makes CPFP reasoning far more accurate than the old per-transaction ancestor accounting.</p>



<p class="wp-block-paragraph">Replacement got stricter at the same time. A replacement is now accepted only if it leaves the mempool&#8217;s overall fee-rate profile strictly better than before, which closes cases where a replacement could make the mempool worse for the next miner. For a standalone transaction the practical test is unchanged: pay more in total and more per byte than what you are replacing.</p>



<figure class="wp-block-image size-large"><img decoding="async" width="1024" height="681" src="https://www.newsbbvn.com/wp-content/uploads/2026/11/fb-3.jpg" alt="A queue outside a money exchange: waiting is the price of a bid that missed" class="wp-image-1061"/><figcaption class="wp-element-caption">Nao Iizuka, CC BY 2.0, via Wikimedia Commons</figcaption></figure>



<p class="wp-block-paragraph">The same release added private broadcast over Tor or I2P. One change from slightly earlier matters just as much if you run Lightning: version-3 transactions under BIP-431 became standard in 28.0, alongside key-less anchor outputs. An anchor is a small, cheap UTXO whose only job is to be spent at a high feerate when you need to bump a commitment transaction. Fee bumping stops being an emergency and becomes a designed step.</p>



<h2 class="wp-block-heading" id="what-i-actually-do-now">What I actually do now</h2>



<ul class="wp-block-list">
<li>Before signing, look at the clearing rate for the next two or three blocks, not the &#8220;recommended&#8221; number, and add a margin if the payment is time-sensitive.</li>


<li>Always leave a change output. It is the difference between a bumpable transaction and a stuck one.</li>


<li>Know who holds the keys. If it is an exchange withdrawal, plan for CPFP from the receiving wallet instead of waiting on support.</li>


<li>Treat zero-confirmation acceptance as a business decision with a price, because the network will not enforce it for you.</li>

</ul>



<p class="wp-block-paragraph">None of this is exotic. It is just the difference between treating a fee as a tip and treating it as a bid in a market that clears every ten minutes. The market does not care how much you meant to send. It only reads your number.</p>



<p class="wp-block-paragraph">(The End)</p>
]]></content:encoded>
					
					<wfw:commentRss>https://www.newsbbvn.com/crypto/bitcoin/1068.html/feed</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Ten Minutes Is an Average, Not a Timetable: How Bitcoin Block Time Actually Behaves</title>
		<link>https://www.newsbbvn.com/crypto/bitcoin/1026.html</link>
					<comments>https://www.newsbbvn.com/crypto/bitcoin/1026.html#respond</comments>
		
		<dc:creator><![CDATA[BBVN Research]]></dc:creator>
		<pubDate>Fri, 30 Oct 2026 07:02:05 +0000</pubDate>
				<category><![CDATA[Bitcoin]]></category>
		<category><![CDATA[bitcoin]]></category>
		<category><![CDATA[crypto]]></category>
		<category><![CDATA[Mining]]></category>
		<guid isPermaLink="false">https://www.newsbbvn.com/markets/1026.html</guid>

					<description><![CDATA[Bitcoin block time is a Poisson process with a 600-second mean, which makes the median wait under seven minutes and the chance of waiting over half an hour about 5%. Six confirmations arrive within an hour only 55% of the time.]]></description>
										<content:encoded><![CDATA[
<div class="k9clock">
<div class="k9-odds"><div class="k9-cell"><span class="k9-cell-n">63.2%</span><small class="k9-cell-l">a block within 10 minutes</small></div><div class="k9-cell k9-cell-alt"><span class="k9-cell-n">36.8%</span><small class="k9-cell-l">longer than the average</small></div></div><p class="k9-odds-p">Waiting longer does not bring the next block closer. The block is not standing behind you in a line, and it has no idea how long you have been waiting.</p>
</div>



<p class="wp-block-paragraph">There is a countdown on almost every block explorer: <em>next block in 04:12</em>. It ticks down while you watch. When it reaches zero, one of two things happens — a block appears, or the number jumps back up to nine minutes and change and starts over.</p>



<p class="wp-block-paragraph">I once left that tab open for an hour on a slow Sunday, mostly out of stubbornness. In that hour I learned the only thing about Bitcoin block timing that actually matters, and it was not about fees, hashrate, or the mempool. It was that the countdown is a decoration. <strong>Bitcoin does not schedule blocks. It schedules the difficulty that makes blocks average out to ten minutes.</strong> Those are not the same statement, and the gap between them explains most of the confusion people have about confirmation times.</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1920" height="1234" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/bt-1.jpg" alt="A Geiger counter, a device whose clicks have no memory of the last click" class="wp-image-1020"/><figcaption class="wp-element-caption">TimVickers, Public domain, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="the-first-analogy-a-geiger-counter-with-no-memory">The First Analogy: A Geiger Counter With No Memory</h2>



<p class="wp-block-paragraph">A Geiger counter next to a lump of uranium clicks at a steady average — say once a second. But it does not click on the second. The gaps between clicks are random, and the distribution of those gaps has a specific and slightly insulting property: it is <strong>memoryless</strong>.</p>



<p class="wp-block-paragraph">If you have waited five seconds in silence, your expected wait for the next click is still one second. It is not shorter because the counter &#8220;owes&#8221; you a click. Nothing accumulated. The counter has no state that remembers the silence.</p>



<p class="wp-block-paragraph">Bitcoin&#8217;s proof-of-work is the same kind of process. Every hash attempt by the entire network is an independent lottery ticket, and the network tries an enormous number of them per second. Nobody is &#8220;close&#8221; to finding a block, because there is no such thing as close — the winning hash is a fresh random draw every time. Miners are not making progress toward a block. They are re-rolling dice at a rate measured in quintillions of rolls per second.</p>



<p class="wp-block-paragraph">That is why the countdown is a lie with good intentions. It is estimating a <em>mean</em>, and drawing it as if it were a <em>deadline</em>.</p>



<h2 class="wp-block-heading" id="the-second-analogy-the-bakery-with-no-timetable">The Second Analogy: The Bakery With No Timetable</h2>



<p class="wp-block-paragraph">My local bakery puts out a fresh tray &#8220;about every ten minutes&#8221;. Over a day that is accurate — forty-odd trays across the morning. But walk in at a random moment and your expected wait is ten minutes, whether the last tray came out thirty seconds ago or eight minutes ago.</p>



<p class="wp-block-paragraph">The bakery, in other words, is not running a queue. It is running a rate. A queue tells you your position; a rate tells you only the average spacing. If you arrive and the tray is empty, the information &#8220;one just came out&#8221; is worth nothing to you, because the baker is not working through a backlog of trays. He is just working.</p>



<p class="wp-block-paragraph">This is the analogy to keep, because it also shows where the bakery analogy breaks — and the break is the important part.</p>



<p class="wp-block-paragraph"><strong>Where it breaks:</strong> the tray is not the block, it is the block <em>space</em>. Bitcoin does have a queue, and it is called the mempool. Transactions sit in it ordered by fee rate, and they get evicted when it fills. If you want to understand that queue — its eviction rules, its 300 MB default ceiling, its 336-hour expiry — I wrote the whole thing down in <a href="https://www.newsbbvn.com/crypto/bitcoin/945.html">what the Bitcoin mempool actually is</a>. What you have to hold in your head simultaneously is that the queue and the clock are two independent random systems, and neither one is aware of the other.</p>



<h2 class="wp-block-heading" id="the-constant-that-makes-it-all-work">The Constant That Makes It All Work</h2>



<p class="wp-block-paragraph">The &#8220;ten minutes&#8221; is not folklore. It is a number in the client:</p>



<pre class="wp-block-code"><code>// Bitcoin Core, chainparams.cpp
consensus.nPowTargetSpacing = 10 * 60;                    // 600 seconds
consensus.nPowTargetTimespan = 14 <em> 24 </em> 60 * 60;         // 1,209,600 seconds
// retarget every 2,016 blocks, clamped to 4x in either direction</code></pre>



<p class="wp-block-paragraph">Every 2,016 blocks — roughly two weeks — the network compares how long those blocks actually took against the 1,209,600 seconds they were supposed to take, and scales the difficulty by that ratio. If blocks came in fast, difficulty rises. If they crawled, it falls. That is the thermostat I took apart in <a href="https://www.newsbbvn.com/crypto/bitcoin/934.html">how the difficulty adjustment works</a>, and its most relevant property here is that it is <em>slow</em>: the target you are mining against was set up to two weeks ago.</p>



<p class="wp-block-paragraph">Satoshi was not guessing about the statistics either. Section 11 of the whitepaper computes the probability of a double-spend by modelling the attacker&#8217;s block arrivals as a <strong>Poisson process</strong> with expected value λ = z·q/p. The distribution was in the design from the first draft. What most readers skip is what a Poisson process implies for the thing they care about — their own wait.</p>



<p class="has-text-align-center wp-block-paragraph"><code>P(wait &gt; t) = e^(−t / 600) · P(next block within 10 min) = 1 − e⁻¹ = 63.2% · median wait = 600·ln2 ≈ 416 s</code></p>



<h2 class="wp-block-heading" id="the-number-that-contradicts-the-label">The Number That Contradicts the Label</h2>



<p class="wp-block-paragraph">Plug in the target and you get a result that surprises almost everyone the first time: if block arrivals follow an exponential distribution with a 600-second mean, the <strong>median</strong> wait is 600 × ln 2, which is about <strong>416 seconds — six minutes and fifty-six seconds.</strong></p>



<p class="has-text-align-center wp-block-paragraph"><strong style="font-size:26px">6.93 min / 36.8% / 4.98%</strong> — </p>



<p class="wp-block-paragraph">median wait for the next block · chance the wait exceeds the 10-minute average · chance the wait exceeds 30 minutes</p>



<p class="wp-block-paragraph">The mean and the median disagree because the distribution is lopsided. Most waits are shorter than ten minutes, and a small number of very long waits drag the average up. There is no such thing as a &#8220;typical ten minute block&#8221;. There is a typical seven-minute block, and an average inflated by the occasional forty-minute one.</p>



<p class="wp-block-paragraph">Here is the table I actually use when somebody asks &#8220;how long does a Bitcoin transaction take&#8221;. Each probability is <code>e^(−t/600)</code>, and the last column converts it to how many of the day&#8217;s ~144 blocks you would expect to see at that spacing.</p>



<figure class="wp-block-table"><table><thead><tr><th>Wait between blocks</th><th>Probability</th><th>Roughly, per day</th></tr></thead><tbody><tr><td>under 1 minute</td><td>9.5%</td><td>about 14 blocks</td></tr><tr><td>over 10 minutes</td><td>36.8%</td><td>about 53 blocks</td></tr><tr><td>over 20 minutes</td><td>13.5%</td><td>about 19 blocks</td></tr><tr><td>over 30 minutes</td><td>5.0%</td><td>about 7 blocks</td></tr><tr><td>over 60 minutes</td><td>0.25%</td><td>one every three days</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">Read the first row again. On a perfectly healthy network, about fourteen times a day two blocks land within a minute of each other. Nothing is wrong. That is just what an exponential distribution looks like when you sample it 144 times.</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1400" height="1050" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/bt-2.jpg" alt="Two dice, each roll independent of the last" class="wp-image-1021"/><figcaption class="wp-element-caption">srgpicker, CC BY 2.0, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="confirmations-are-a-sum-of-coin-flips">Confirmations Are a Sum of Coin Flips</h2>



<p class="wp-block-paragraph">One confirmation is not &#8220;the block containing my transaction&#8221;. It is &#8220;the block, plus every block after it&#8221;, and each of those is an independent exponential draw. So the wait for <code>n</code> confirmations is not exponential — it is a sum of exponentials, which is the Erlang/gamma distribution, and it behaves much better than a single interval.</p>



<figure class="wp-block-table"><table><thead><tr><th>Target</th><th>Mean wait</th><th>Median wait</th><th>Chance you are done within an hour</th></tr></thead><tbody><tr><td>1 confirmation</td><td>10.0 min</td><td>6.9 min</td><td>99.8%</td></tr><tr><td>3 confirmations</td><td>30.0 min</td><td>26.7 min</td><td>93.8%</td></tr><tr><td>6 confirmations</td><td>60.0 min</td><td>56.7 min</td><td>55.4%</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">That last row is the one to sit with. Six confirmations is the industry&#8217;s default assumption for &#8220;settled&#8221;, and it corresponds to an hour on average — but <strong>only 55% of the time do six blocks actually arrive inside an hour.</strong> The other 45% of the time you are waiting longer, sometimes much longer, and none of that indicates a problem with the network, the miners, or your transaction.</p>



<p class="wp-block-paragraph"><strong>Six confirmations is not a receipt. It is a probability with a widely-advertised round number attached to it.</strong> If you are timing something that genuinely needs an hour, you need a wider margin than the folklore gives you.</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1400" height="1899" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/bt-3.jpg" alt="A pendulum clock, a machine built to average out, not to promise" class="wp-image-1022"/><figcaption class="wp-element-caption">John Jordan, CC0, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="three-things-this-should-change-in-practice">Three Things This Should Change In Practice</h2>



<div class="wp-block-getwid-icon-box has-text-left has-background" style="background-color:#fbfcfd;padding:18px;border-radius:10px">
<div class="wp-block-getwid-icon-box__icon-container is-position-top"><div class="wp-block-getwid-icon-box__icon-wrapper" style="font-size:24px"><i class="fas fa-hourglass-half" aria-hidden="true"></i></div></div>
<div class="wp-block-getwid-icon-box__content">
<h4 class="wp-block-heading">Waiting longer is not evidence of anything</h4>
<p>The gambler&#8217;s fallacy does not apply here, but the opposite one does: people read a 25-minute gap as &#8220;a block is due&#8221;. It is not. The expected wait from minute 25 is ten minutes, exactly as it was from minute zero. If your confirmation is late, the correct conclusion is that you are in the 36.8%, not that you are close.</p>
</div>
</div>



<div class="wp-block-getwid-icon-box has-text-left has-background" style="background-color:#fbfcfd;padding:18px;border-radius:10px">
<div class="wp-block-getwid-icon-box__icon-container is-position-top"><div class="wp-block-getwid-icon-box__icon-wrapper" style="font-size:24px"><i class="fas fa-layer-group" aria-hidden="true"></i></div></div>
<div class="wp-block-getwid-icon-box__content">
<h4 class="wp-block-heading">The fee buys position, not time</h4>
<p>Paying more does not shorten the interval to the next block. It buys you a slot in the block that eventually arrives, which matters enormously when the mempool is deep and not at all when it is empty. Two independent systems: the clock sets <em>when</em>, the fee sets <em>whether</em>.</p>
</div>
</div>



<div class="wp-block-getwid-icon-box has-text-left has-background" style="background-color:#fbfcfd;padding:18px;border-radius:10px">
<div class="wp-block-getwid-icon-box__icon-container is-position-top"><div class="wp-block-getwid-icon-box__icon-wrapper" style="font-size:24px"><i class="fas fa-chart-line" aria-hidden="true"></i></div></div>
<div class="wp-block-getwid-icon-box__content">
<h4 class="wp-block-heading">Pick your confirmation count from the table, not from habit</h4>
<p>If a merchant waits for 6 confirmations, they are accepting a 55% chance of settling within the hour. If they need 95% within the hour, they need fewer confirmations and a different risk model — or a payment channel. The number should come from the distribution, not from 2009&#8217;s forum posts.</p>
</div>
</div>



<p class="wp-block-paragraph">And one caveat that belongs in every article about averages: the &#8220;ten minutes&#8221; is a <em>target whose error is corrected every two weeks</em>. When hashrate grows fast, blocks come in a little faster than 600 seconds until the next retarget catches up; when miners shut off in a hurry, they come in slower. The distribution shape holds. The mean is a moving estimate, not a constant — which is another way of saying that even the average you are comparing yourself to is the network&#8217;s best guess from two weeks ago.</p>



<p class="wp-block-paragraph">The habit worth building is small: when a transaction feels slow, ask which of the two systems you are actually waiting on. If your fee rate is above the current mempool floor, the answer is &#8220;the clock&#8221;, and the clock owes you nothing. If your fee rate is below it, the answer is &#8220;the queue&#8221;, and the queue can be bought out of — or, in the case of a stuck transaction, replaced. Those are two different problems with two different fixes, and people routinely spend money on the wrong one.</p>



<p class="wp-block-paragraph">So here is the question I would leave you with, and it is not rhetorical. <strong>If ten minutes was never a schedule, what else in this market are you still reading as one?</strong></p>



<p class="wp-block-paragraph">(The End)</p>
]]></content:encoded>
					
					<wfw:commentRss>https://www.newsbbvn.com/crypto/bitcoin/1026.html/feed</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>The Transaction That Mints Money: How a Coinbase Reward Is Born Every Ten Minutes</title>
		<link>https://www.newsbbvn.com/crypto/bitcoin/1011.html</link>
					<comments>https://www.newsbbvn.com/crypto/bitcoin/1011.html#respond</comments>
		
		<dc:creator><![CDATA[BBVN Research]]></dc:creator>
		<pubDate>Tue, 27 Oct 2026 06:11:31 +0000</pubDate>
				<category><![CDATA[Bitcoin]]></category>
		<category><![CDATA[bitcoin]]></category>
		<category><![CDATA[crypto]]></category>
		<guid isPermaLink="false">https://www.newsbbvn.com/markets/1011.html</guid>

					<description><![CDATA[The coinbase transaction has no input and mints new bitcoin from nothing. It is the only door through which supply enters, it obeys a 100-block maturity rule, and it is how the 21-million cap actually falls out of a geometric series.]]></description>
										<content:encoded><![CDATA[
<div class="k8mint">
<span class="k8-mint-amt">50 BTC</span><p class="k8-mint-p">Every block starts by paying its author</p><div class="k8-mint-bar"><span class="k8-mint-fill"></span></div><em class="k8-mint-cap">→ 21,000,000</em>
</div>



<ul class="wp-block-list">
<li>That is how many bitcoin the first block&#8217;s coinbase transaction created, out of nothing, on January 3, 2009. No input, no sender, no previous owner. Just an output paying 50 BTC to a public key, and a bit of arbitrary data in the input field that read &#8220;The Times 03/Jan/2009 Chancellor on brink of second bailout for banks.&#8221;</li>

</ul>



<p class="wp-block-paragraph">Every ~10 minutes since, a new transaction of this kind has been born at the top of a block. It is the one place in the entire system where bitcoin is created rather than moved, and it obeys rules that almost nobody reads because they are boring until the moment they decide the supply.</p>



<p class="wp-block-paragraph">So let me read them, because this is the mechanism behind the &#8220;21 million&#8221; number everybody quotes and almost nobody derives.</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1920" height="1234" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/coinbase-1.jpg" alt="A late-Qing minting press, the machine that makes money from nothing" class="wp-image-1004"/><figcaption class="wp-element-caption">Gary Lee Todd, CC0, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="the-coinbase-is-not-a-reward-it-is-a-transaction">The Coinbase Is Not a Reward; It Is a Transaction</h2>



<p class="wp-block-paragraph">First, a naming correction that matters. The &#8220;coinbase transaction&#8221; is not a special bonus line in the block. It is an ordinary transaction with <strong>one hard-coded exception: its input list is empty.</strong></p>



<p class="wp-block-paragraph">Every normal transaction must name a previous output to spend — that 36-byte outpoint we walked through in the <a href="/crypto/bitcoin/995.html">transaction anatomy</a> piece. The coinbase transaction has no such outpoint. Its single input carries a null reference and a field that can hold arbitrary bytes, which is why it is the one place miners can write &#8220;The Times&#8221; headlines or, later, pool names and BIP-34 block-height commitments.</p>



<pre class="wp-block-code"><code>normal input:  prevout(36 bytes) + scriptSig + nSequence
coinbase input:  null outpoint + coinbase_script (up to 100 bytes, arbitrary) + nSequence</code></pre>



<p class="wp-block-paragraph">Because there is no previous owner, there is nothing to spend — which is exactly what allows value to appear from nowhere. The output is the newly created bitcoin, and the whole construction is valid only in one position: <strong>the first transaction in the block.</strong></p>



<div class="k8tape">
<ul class="k8-tape"><li><mark class="k8-when">Jan 3, 2009</mark><span class="k8-what">Genesis block coinbase pays 50 BTC; the input carries a Times headline</span></li><li><mark class="k8-when">50 BTC</mark><span class="k8-what">The original block subsidy, before the first halving</span></li><li><mark class="k8-when">Nov 28, 2012</mark><span class="k8-what">First halving at block 210,000 — subsidy drops to 25 BTC</span></li><li><mark class="k8-when">Jul 9, 2016</mark><span class="k8-what">Second halving at block 420,000 — 12.5 BTC</span></li><li><mark class="k8-when">May 11, 2020</mark><span class="k8-what">Third halving at block 630,000 — 6.25 BTC</span></li><li><mark class="k8-when">Apr 2024</mark><span class="k8-what">Fourth halving at block 840,000 — 3.125 BTC</span></li><li><mark class="k8-when">~2140</mark><span class="k8-what">The last satoshi is issued; subsidy becomes zero</span></li></ul>
</div>



<h2 class="wp-block-heading" id="where-the-21-million-actually-comes-from">Where the 21 Million Actually Comes From</h2>



<p class="wp-block-paragraph">The number 21 million is not written anywhere in the code as a target. It falls out of two rules that combine into a geometric series.</p>



<p class="has-text-align-center wp-block-paragraph"><code>subsidy per block = 50 · 2^(-halving) satoshi · a halving every 210,000 blocks</code></p>



<p class="wp-block-paragraph">Start at 50 BTC per block. Every 210,000 blocks — about four years — cut it in half. Sum the infinite series and you get 21 million, because 50 × 210,000 × (1 + ½ + ¼ + …) = 50 × 210,000 × 2 = 21,000,000. The cap is not a constant; it is a limit.</p>



<figure class="wp-block-table"><table><thead><tr><th>Halving</th><th>Block height</th><th>Subsidy after it</th></tr></thead><tbody><tr><td>Genesis</td><td>0</td><td>50 BTC</td></tr><tr><td>1st</td><td>210,000 (Nov 2012)</td><td>25 BTC</td></tr><tr><td>2nd</td><td>420,000 (Jul 2016)</td><td>12.5 BTC</td></tr><tr><td>3rd</td><td>630,000 (May 2020)</td><td>6.25 BTC</td></tr><tr><td>4th</td><td>840,000 (Apr 2024)</td><td>3.125 BTC</td></tr><tr><td>33rd</td><td>~2140</td><td>0 (last satoshi issued)</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">That is the elegant part. The inelegant part is that the number is <em>slightly</em> less than 21 million in practice, because a handful of coinbase outputs were destroyed through bugs or lost keys over the years, and because the subsidy is paid in an integer number of satoshi that cannot always be halved exactly.</p>



<p class="has-text-align-center wp-block-paragraph"><strong style="font-size:26px">210,000 / ~4 years / 21,000,000</strong> — </p>



<p class="wp-block-paragraph">blocks between halvings · the real-world cadence of each halving · the supply limit that falls out of the geometric series</p>



<h2 class="wp-block-heading" id="two-more-pieces-of-the-same-transaction">Two More Pieces of the Same Transaction</h2>



<p class="wp-block-paragraph">The subsidy is only the first thing the coinbase transaction collects. It also gathers <strong>everything else the block produced.</strong></p>



<p class="wp-block-paragraph"><strong>Transaction fees.</strong> Every transaction&#8217;s fee is the difference between its inputs and outputs — the leftover that the miner implicitly claims. The coinbase transaction&#8217;s total output value is allowed to be up to the subsidy <em>plus</em> the sum of every fee in the block, but not a satoshi more. That &#8220;not more&#8221; is a consensus rule, and it is what caps the miner&#8217;s take.</p>



<p class="wp-block-paragraph"><strong>Why this becomes the whole story.</strong> As the subsidy halves toward zero, fees become the only thing left. The design assumption baked in from the start is that by the time the subsidy is negligible, transaction fees will have grown large enough to keep miners honest — which is a bet, not a guarantee, and the subject of a debate that will get loud around the sixth and seventh halvings.</p>



<p class="has-text-align-center wp-block-paragraph"><code>coinbase output ≤ subsidy + Σ(fees in block) · and the subsidy is the only part that eventually disappears</code></p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1400" height="945" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/coinbase-2.jpg" alt="An engraving of a coining press from Old and New London" class="wp-image-1005"/><figcaption class="wp-element-caption">Unknown author, Public domain, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="the-100-block-trap-that-catches-every-new-miner">The 100-Block Trap That Catches Every New Miner</h2>



<p class="wp-block-paragraph">There is a rule attached to coinbase outputs that quietly changes the meaning of &#8220;you just mined a block&#8221;: <strong>the newly created coins cannot be spent for 100 blocks.</strong></p>



<p class="wp-block-paragraph">Technically, the rule is that a transaction spending a coinbase output is invalid until the coinbase has 100 confirmations. The reason is not to punish miners — it is to protect the ledger from its own reorgs. If the chain reorganizes and your block ends up orphaned, its coinbase is invalid, and anything you already spent with it would have to be unwound. The 100-block maturity window makes sure the coinbase is deep enough to be near-immovable before it can move.</p>



<p class="wp-block-paragraph">The practical consequence is a miner&#8217;s cash-flow rhythm: <strong>you cannot spend what you just mined until roughly 16 to 17 hours later.</strong> Every new pool operator learns this the hard way when the payout dashboard shows a balance that the wallet will not yet let them touch.</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1400" height="2100" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/coinbase-3.jpg" alt="Scales for weighing gold — the accounting behind the mint" class="wp-image-1006"/><figcaption class="wp-element-caption">Thomas Quine, CC BY 2.0, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="what-this-means-for-the-21-million-you-hear-everywhere">What This Means for the &#8220;21 Million&#8221; You Hear Everywhere</h2>



<p class="wp-block-paragraph">Put it all together and the supply story is more specific than the slogan:</p>



<ul class="wp-block-list">
<li><strong>The cap is a limit, not a constant.</strong> 21 million is the sum of a geometric series, and the real figure is a hair below it because of destroyed coins and rounding.</li>


<li><strong>The subsidy is already mostly gone.</strong> At 3.125 BTC per block after the 2024 halving, roughly 93.75% of all bitcoin that will ever exist has already been issued. The remaining issuance is a rounding error next to the float.</li>


<li><strong>The interesting number is the fee, not the subsidy.</strong> The coinbase output is capped at subsidy-plus-fees, and the subsidy is on a one-way trip to zero. The security budget of the network is being handed from newly-minted coins to transaction fees, on a schedule nobody fully controls.</li>


<li><strong>&#8220;Mining creates money&#8221; is true exactly once per block, in exactly one position.</strong> Every other transaction just moves what already exists.</li>

</ul>



<p class="wp-block-paragraph">The coinbase transaction is the only door through which new bitcoin enters the world, and it is open for a fixed, shrinking amount every ten minutes. That is the entire supply policy of the hardest money ever built, and it fits in a transaction with no input.</p>



<p class="wp-block-paragraph">(The End)</p>
]]></content:encoded>
					
					<wfw:commentRss>https://www.newsbbvn.com/crypto/bitcoin/1011.html/feed</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>The Signature Bitcoin Waited 12 Years For: What Schnorr Adds That ECDSA Couldn&#8217;t</title>
		<link>https://www.newsbbvn.com/crypto/bitcoin/1010.html</link>
					<comments>https://www.newsbbvn.com/crypto/bitcoin/1010.html#respond</comments>
		
		<dc:creator><![CDATA[BBVN Research]]></dc:creator>
		<pubDate>Tue, 27 Oct 2026 06:11:24 +0000</pubDate>
				<category><![CDATA[Bitcoin]]></category>
		<category><![CDATA[bitcoin]]></category>
		<category><![CDATA[crypto]]></category>
		<guid isPermaLink="false">https://www.newsbbvn.com/markets/1010.html</guid>

					<description><![CDATA[Bitcoin shipped with ECDSA in 2009 because Schnorr's patent had only just expired. What it gained in November 2021 is linearity: signatures that add up, keys that aggregate, and multisig that stops announcing itself.]]></description>
										<content:encoded><![CDATA[
<div class="k8sig">
<span class="k8-sig-b">64 bytes</span><span class="k8-sig-e">R · s</span><p class="k8-sig-p">The whole difference is one missing division.</p><code class="k8-sig-eq">s·G = R + e·P</code>
</div>



<p class="wp-block-paragraph">Bitcoin shipped in 2009 with the second-best signature scheme, and it was not a mistake someone made — it was a patent. Claus Schnorr held US patent 4,995,082 over the scheme that now carries his name, and it did not expire until February 2008, a few months before the whitepaper appeared. So Satoshi used ECDSA, the unencumbered standard, and the network spent twelve years paying for that choice in bytes and in privacy. Then, in November 2021, at block 709,632, Bitcoin quietly switched to Schnorr for everything new.</p>



<p class="wp-block-paragraph">The thing that makes Schnorr different from ECDSA is one word: <strong>linearity</strong>. And it is the kind of property that sounds like a math footnote and turns out to rewrite what a wallet can do.</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1920" height="1234" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/schnorr-1.jpg" alt="A ceremonial handshake — many parties collapsing into one agreement" class="wp-image-1001"/><figcaption class="wp-element-caption">s.yume, CC BY 2.0, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="two-analogies-that-actually-hold">Two Analogies That Actually Hold</h2>



<p class="wp-block-paragraph">Here are the two analogies I keep coming back to, because each one explains a different half of what &#8220;linear&#8221; buys you.</p>



<p class="wp-block-paragraph"><strong>The paper shredder versus the seal.</strong> ECDSA&#8217;s signature is like a paper shredder: it mangles the message and the key into an output you cannot reverse, and two shreddings cannot be recombined into one. Schnorr&#8217;s signature is like a wax seal on a chain of custody — the pieces stay algebraically whole, so two seals on the same document can be pressed together into one seal for the two signers combined. Nothing about the message is hidden either way; the difference is what you can <em>do</em> with the signature afterward.</p>



<p class="wp-block-paragraph"><strong>The invoice versus the itemized bill.</strong> A 2-of-3 multisig spent the old way publishes two signatures and three public keys, every time, forever. That is an itemized bill for your security policy. Spent the Schnorr way, it publishes one signature against one key — an invoice, with no line items. Both settle the same debt. One of them tells the whole room how many people were involved.</p>



<p class="has-text-align-center wp-block-paragraph"><code>verification: s·G = R + e·P · where e = hash(R‖P‖m) · because s = k + e·d and R = k·G</code></p>



<h2 class="wp-block-heading" id="where-the-linearity-comes-from">Where the Linearity Comes From</h2>



<p class="wp-block-paragraph">The whole difference reduces to a single missing operation. ECDSA&#8217;s signing step requires a <strong>modular inverse</strong> — a division, essentially — and that inverse is what breaks the linearity. Schnorr&#8217;s signing step is pure addition and multiplication:</p>



<pre class="wp-block-code"><code># signing with private key d, secret nonce k
R = k * G
e = hash(R || P || m)      # the challenge, computed via Fiat-Shamir
s = k + e * d              # just addition and multiplication
signature = (R, s)          # 64 bytes total</code></pre>



<p class="wp-block-paragraph">Because there is no division, the signature is a <em>linear</em> function of the private key. Add two private keys, and the sum signs for the sum of the public keys. The verification equation <code>s·G = R + e·P</code> is the same arithmetic rearranged.</p>



<p class="wp-block-paragraph">The practical payoffs are three, and they stack:</p>



<p class="has-text-align-center wp-block-paragraph"><strong style="font-size:26px">64 / 32 / 2–3×</strong> — </p>



<p class="wp-block-paragraph">bytes in a Schnorr signature · bytes in an x-only public key · batch-verification speedup a node can get</p>



<ul class="wp-block-list">
<li><strong>Key aggregation.</strong> A group of signers can hold one apparent public key between them, and produce one signature that verifies against it. On chain, a fifteen-signer arrangement is indistinguishable from a single wallet.</li>


<li><strong>Batch verification.</strong> Because the equation is linear, a node can combine hundreds of signatures into one multi-scalar multiplication and check them together, with random coefficients to stop one invalid signature from masking another.</li>


<li><strong>Non-malleability.</strong> ECDSA signatures can be transformed into other, equally-valid signatures for the same message — a nuisance for every higher-layer protocol. Schnorr is non-malleable by construction.</li>

</ul>



<figure class="wp-block-table"><table><thead><tr><th></th><th>ECDSA</th><th>Schnorr (BIP-340)</th></tr></thead><tbody><tr><td>Signature size</td><td>71–72 bytes, DER-encoded, variable</td><td>64 bytes, fixed</td></tr><tr><td>Public key</td><td>33 bytes compressed (or 65 uncompressed)</td><td>32 bytes, x-only</td></tr><tr><td>Combine signatures</td><td>not possible</td><td>linear, adds up</td></tr><tr><td>Batch verify</td><td>no</td><td>yes, ~2–3× speedup</td></tr><tr><td>Malleable</td><td>yes</td><td>no, by construction</td></tr><tr><td>In Bitcoin since</td><td>2009</td><td>block 709,632 (Nov 2021)</td></tr></tbody></table></figure>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1400" height="1792" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/schnorr-2.jpg" alt="A coining press at the Royal Mint" class="wp-image-1002"/><figcaption class="wp-element-caption">RedCoat10, Public domain, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="the-two-footguns-the-spec-exists-to-prevent">The Two Footguns the Spec Exists to Prevent</h2>



<p class="wp-block-paragraph">The reason Schnorr needs a formal BIP at all is that &#8220;just do the math&#8221; is not a signature scheme — it is a consensus split waiting to happen. BIP-340 pins down two things that would otherwise bite.</p>



<p class="wp-block-paragraph"><strong>Key prefixing.</strong> The challenge <code>e</code> hashes <code>R</code>, the public key <code>P</code>, <em>and</em> the message together. That seems redundant until you realize it blocks related-key attacks: without the public key in the hash, a signature valid for one key can sometimes be repurposed against another. Including <code>P</code> is what makes key aggregation and the Taproot tweak safe.</p>



<p class="wp-block-paragraph"><strong>Tagged hashes.</strong> Every hash inside the scheme is prefixed with a domain string — <code>BIP0340/challenge</code>, <code>BIP0340/nonce</code>, and so on. A hash computed for a signature challenge can never be mistaken for one computed for something else that happens to hash similar bytes. That is domain separation, and it is the kind of thing that only matters in the bug you never ship.</p>



<p class="wp-block-paragraph">And the nonce is still the sharp edge, exactly as it was in the ECDSA piece. Reuse <code>k</code> across two messages and the private key falls out of simple subtraction. BIP-340&#8217;s answer is a deterministic nonce derived from the key and message, XORed with fresh auxiliary randomness — safe even on hardware with a mediocre random number generator.</p>



<div class="wp-block-getwid-testimonial"><div class="wp-block-getwid-testimonial__wrapper"><div class="wp-block-getwid-testimonial__content-wrapper"><div class="wp-block-getwid-testimonial__content">The whole point of the signature scheme is that the interesting math moved off-chain. What stays on chain is the boring, indistinguishable, 64-byte result.</div><div class="wp-block-getwid-testimonial__meta"><div class="wp-block-getwid-testimonial__title"></div><div class="wp-block-getwid-testimonial__subtitle"></div></div></div></div></div>



<h2 class="wp-block-heading" id="what-it-costs-you-to-keep-using-ecdsa">What It Costs You to Keep Using ECDSA</h2>



<p class="wp-block-paragraph">None of this changes the fact that most bitcoin still sits in pre-Taproot outputs, and every one of those spends uses ECDSA. The two schemes live side by side, and the cost of staying old is measurable:</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1400" height="933" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/schnorr-3.jpg" alt="Two players shaking hands after a match" class="wp-image-1003"/><figcaption class="wp-element-caption">kance, CC BY 2.0, via Wikimedia Commons</figcaption></figure>



<ul class="wp-block-list">
<li><strong>You pay the itemized bill.</strong> Every legacy multisig spend publishes every key and every signature. The fee difference compounds across the consolidations long-term holders inevitably do.</li>


<li><strong>You keep the tell.</strong> Chain-analysis firms classify addresses by shape, and multisig has always been a loud shape. Protecting yourself properly used to announce that you had something worth protecting.</li>


<li><strong>You miss the batch discount.</strong> Nodes verifying your blocks do not get the ~2–3× speedup Schnorr enables during initial block download, which is a network-wide cost, not just yours.</li>

</ul>



<p class="wp-block-paragraph">The honest summary for a single-key holder is that the switch is a rounding error — one signature gets a few bytes smaller, and that is about it. The payoff is for anyone doing multisig, Lightning, or Taproot, and it is not a fee optimization. It is that <strong>the shape of your spending stops revealing how many people signed it.</strong></p>



<p class="wp-block-paragraph">(The End)</p>
]]></content:encoded>
					
					<wfw:commentRss>https://www.newsbbvn.com/crypto/bitcoin/1010.html/feed</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>The Branch You Never Reveal: How Taproot Hides a Script Tree Behind One Key</title>
		<link>https://www.newsbbvn.com/crypto/bitcoin/996.html</link>
					<comments>https://www.newsbbvn.com/crypto/bitcoin/996.html#respond</comments>
		
		<dc:creator><![CDATA[BBVN Research]]></dc:creator>
		<pubDate>Wed, 21 Oct 2026 05:52:52 +0000</pubDate>
				<category><![CDATA[Bitcoin]]></category>
		<category><![CDATA[bitcoin]]></category>
		<category><![CDATA[crypto]]></category>
		<guid isPermaLink="false">https://www.newsbbvn.com/markets/996.html</guid>

					<description><![CDATA[A cooperative multisig spend under Taproot is one 64-byte signature that looks like an ordinary payment. Nothing is encrypted — the unused branches simply never go on chain. Here is the tweak, the tree, and the boundary of what it hides.]]></description>
										<content:encoded><![CDATA[
<div class="k7panel">
<div class="k7-panel"><h4 class="k7-panel-t">One key on chain, a tree of alternatives off it</h4><p class="k7-panel-s">Nothing here is encrypted. It is simply not on chain.</p><span class="k7-tag">BIP-341 taproot</span></div>
</div>



<p class="wp-block-paragraph">Compare two transactions from the same multisig wallet, six years apart.</p>



<p class="wp-block-paragraph">The 2019 one is a wall of public keys. Three signatures, five public keys, an <code>OP_3 ... OP_5 OP_CHECKMULTISIG</code> redeem script, a P2SH wrapper — all of it on chain, all of it readable by anyone with a block explorer, all of it screaming <em>this is an institutional multisig with a five-person quorum</em>. Roughly 370 bytes of input, and an announcement.</p>



<p class="wp-block-paragraph">The 2022 one is <strong>one 64-byte signature</strong>. That is the entire witness. It looks exactly like a person paying for coffee with a single-key wallet. No keys, no script, no quorum, no indication that a script tree exists at all.</p>



<p class="wp-block-paragraph">Same wallet. Same policy. Same five signers. The difference is Taproot, and the thing worth understanding is that <strong>Taproot does not encrypt the policy — it omits it.</strong> Nothing is hidden behind cryptography here. The data is simply not on chain, because in the cooperative case it never has to be.</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1920" height="1234" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/taproot-1.jpg" alt="A tree's branching silhouette — the shape a script tree takes, most of it unvisited" class="wp-image-988"/><figcaption class="wp-element-caption">Arnab02, CC BY 4.0, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="the-entity-stack">The Entity Stack</h2>



<p class="wp-block-paragraph">It helps to stack Taproot into five layers, because each layer answers exactly one question.</p>



<div class="wp-block-getwid-icon-box has-text-left has-background" style="background-color:#fbfcfd;padding:18px;border-radius:10px">
<div class="wp-block-getwid-icon-box__icon-container is-position-top"><div class="wp-block-getwid-icon-box__icon-wrapper" style="font-size:24px"><i class="fas fa-key" aria-hidden="true"></i></div></div>
<div class="wp-block-getwid-icon-box__content">
<h4 class="wp-block-heading">Layer 1 — The internal key (P)</h4>
<p>A 32-byte x-only public key. In the multisig case this is an <em>aggregated</em> key: five parties run MuSig2 and produce one key that none of them can sign for alone. To an observer it is indistinguishable from a single person&#8217;s key.</p>
</div>
</div>



<div class="wp-block-getwid-icon-box has-text-left has-background" style="background-color:#fbfcfd;padding:18px;border-radius:10px">
<div class="wp-block-getwid-icon-box__icon-container is-position-top"><div class="wp-block-getwid-icon-box__icon-wrapper" style="font-size:24px"><i class="fas fa-sitemap" aria-hidden="true"></i></div></div>
<div class="wp-block-getwid-icon-box__content">
<h4 class="wp-block-heading">Layer 2 — The script tree root (R)</h4>
<p>An optional Merkle root over alternative spending conditions. Each leaf is a script plus a one-byte leaf version. If there are no alternative conditions, R is empty — and the construction below still runs, which is what prevents key reuse from leaking the internal key.</p>
</div>
</div>



<div class="wp-block-getwid-icon-box has-text-left has-background" style="background-color:#fbfcfd;padding:18px;border-radius:10px">
<div class="wp-block-getwid-icon-box__icon-container is-position-top"><div class="wp-block-getwid-icon-box__icon-wrapper" style="font-size:24px"><i class="fas fa-calculator" aria-hidden="true"></i></div></div>
<div class="wp-block-getwid-icon-box__content">
<h4 class="wp-block-heading">Layer 3 — The tweak (t)</h4>
<p><code>t = TaggedHash("TapTweak", P || R)</code>. This is the step that commits the output to <em>both</em> the key and the tree, without revealing either.</p>
</div>
</div>



<div class="wp-block-getwid-icon-box has-text-left has-background" style="background-color:#fbfcfd;padding:18px;border-radius:10px">
<div class="wp-block-getwid-icon-box__icon-container is-position-top"><div class="wp-block-getwid-icon-box__icon-wrapper" style="font-size:24px"><i class="fas fa-compress" aria-hidden="true"></i></div></div>
<div class="wp-block-getwid-icon-box__content">
<h4 class="wp-block-heading">Layer 4 — The output key (Q)</h4>
<p><code>Q = lift_x(P) + tG</code>, and the chain stores only <code>x(Q)</code>. That is the 32-byte witness program. Every Taproot output is 34 bytes of scriptPubKey — <code>OP_1</code> followed by that x coordinate — and they are all structurally identical regardless of what they commit to.</p>
</div>
</div>



<div class="wp-block-getwid-icon-box has-text-left has-background" style="background-color:#fbfcfd;padding:18px;border-radius:10px">
<div class="wp-block-getwid-icon-box__icon-container is-position-top"><div class="wp-block-getwid-icon-box__icon-wrapper" style="font-size:24px"><i class="fas fa-signature" aria-hidden="true"></i></div></div>
<div class="wp-block-getwid-icon-box__content">
<h4 class="wp-block-heading">Layer 5 — The two ways to spend</h4>
<p>Key path: one signature for Q. Script path: reveal one leaf, its inputs, and a control block. Layer 5 is where the privacy is actually spent or not spent.</p>
</div>
</div>



<p class="has-text-align-center wp-block-paragraph"><code>Q = lift_x(P) + TaggedHash("TapTweak", P‖R)·G · scriptPubKey = OP_1 &lt;32-byte x(Q)&gt; · address = bc1p…</code></p>



<h2 class="wp-block-heading" id="what-the-two-spend-paths-cost">What the Two Spend Paths Cost</h2>



<div class="k7stages">
<div class="k7-stages"><div class="k7-stage"><i class="k7-when">Nov 14, 2021</i><b class="k7-what">Taproot activates at block 709,632 — a soft fork, no flag day for users</b></div><div class="k7-stage"><i class="k7-when">Key path</i><b class="k7-what">Witness is a single element: 64 bytes (SIGHASH_DEFAULT) or 65 with an explicit sighash byte</b></div><div class="k7-stage"><i class="k7-when">Script path</i><b class="k7-what">Witness is [script arguments…, leaf script, control block]</b></div><div class="k7-stage"><i class="k7-when">Control block</i><b class="k7-what">33 + 32m bytes, where m is the Merkle path length, m ∈ [0, 128]</b></div><div class="k7-stage"><i class="k7-when">Verification</i><b class="k7-what">Rebuild the root from leaf + path, recompute Q = P + tG, compare against the output</b></div></div>
</div>



<p class="wp-block-paragraph">The control block is the piece that makes this auditable. Its first byte packs <code>(leaf_version &amp; 0xfe) | parity(Q)</code>; the next 32 bytes are the internal key P; everything after is the sibling hashes. A validator recomputes the tweak from what it was handed and checks that the result equals the output key it already has. <strong>If the path is wrong, the arithmetic does not close</strong> — there is no separate signature proving the script belonged to the output.</p>



<figure class="wp-block-table"><table><thead><tr><th></th><th>Key path</th><th>Script path</th></tr></thead><tbody><tr><td>Witness contents</td><td>one 64-byte signature</td><td>stack args, then the leaf script, then the control block</td></tr><tr><td>What it reveals</td><td>nothing at all about the tree</td><td>that one leaf, plus the Merkle path to the root</td></tr><tr><td>Requires the parties to cooperate</td><td>yes</td><td>no</td></tr><tr><td>Why you would use it</td><td>normal spending, cheapest case</td><td>fallback: counterparty silent, timelock reached, arbitration</td></tr><tr><td>On-chain fingerprint</td><td>identical to any single-key payment</td><td>visibly a script spend, forever</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">Two details I find genuinely elegant:</p>



<p class="wp-block-paragraph"><strong>Branch hashes are sorted lexicographically</strong> before hashing, so the Merkle path needs no left/right direction bits. Both children are hashed in a canonical order, so the verifier never has to be told which side it is climbing from. That is 1 bit saved per level and one whole class of implementation bug removed.</p>



<p class="wp-block-paragraph"><strong>The most likely script belongs near the root.</strong> A typical policy is &#8220;cooperative path, or after 90 days a timelock recovery, or in an emergency the arbitration key.&#8221; Put the timelock recovery at depth 1 and the emergency key at depth 4, and the common failure case proves in 32 bytes instead of 128.</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1400" height="787" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/taproot-2.jpg" alt="Morning light through a redwood grove in Muir Woods" class="wp-image-989"/><figcaption class="wp-element-caption">Dale Cruse, CC BY 4.0, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="what-taproot-does-not-hide">What Taproot Does Not Hide</h2>



<p class="wp-block-paragraph">This is where the marketing gets ahead of the specification, so let me be blunt about the boundary.</p>



<p class="wp-block-paragraph"><strong>Amounts are still public.</strong> Taproot hides <em>conditions</em>, not <em>values</em>. Every output&#8217;s satoshi figure is in the transaction in plaintext and always will be, unless something like Confidential Transactions ships, which it has not.</p>



<p class="wp-block-paragraph"><strong>Input and output linkage is still public.</strong> A key-path spend reveals nothing about the script tree, and simultaneously reveals that these specific coins moved to those specific outputs. Chain analysis does not need your script; it needs your graph.</p>



<p class="wp-block-paragraph"><strong>The absence of a script path is not evidence of a simple wallet.</strong> That is the point of the uniform 34-byte output: you cannot tell whether a <code>bc1p</code> address is a single key or a five-way quorum with an arbitration fallback. Anonymity here is <em>indistinguishability</em>, not concealment — and indistinguishability is only as strong as the number of ordinary single-key users who also use <code>bc1p</code>.</p>



<div class="wp-block-getwid-testimonial"><div class="wp-block-getwid-testimonial__wrapper"><div class="wp-block-getwid-testimonial__content-wrapper"><div class="wp-block-getwid-testimonial__content">Taproot did not make transactions private. It made one specific fact — how many conditions you attached — stop being visible. People keep reading that as &#8220;Bitcoin got privacy,&#8221; and then get surprised when their change output still links their coins.</div><div class="wp-block-getwid-testimonial__meta"><div class="wp-block-getwid-testimonial__title">A wallet engineer</div><div class="wp-block-getwid-testimonial__subtitle">conflating two different guarantees</div></div></div></div></div>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1400" height="1600" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/taproot-3.jpg" alt="Pruning shears — the tool for deciding which branches never appear" class="wp-image-990"/><figcaption class="wp-element-caption">KVDP, Public domain, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="tapscript-what-changed-inside-the-leaf">Tapscript: What Changed Inside the Leaf</h2>



<p class="wp-block-paragraph">The script rules for leaf version <code>0xc0</code> are not the same rules as pre-Taproot Script, and the differences are not cosmetic:</p>



<ul class="wp-block-list">
<li><strong><code>OP_CHECKMULTISIG</code> and <code>OP_CHECKMULTISIGVERIFY</code> are disabled.</strong> In their place, <code>OP_CHECKSIGADD</code> counts successful individual checks. Threshold policy becomes a counting exercise rather than a special-cased opcode. Note what this does <em>not</em> do: it does not aggregate signatures. A 3-of-5 script-path spend still carries three separate signatures; aggregation is MuSig2&#8217;s job, off chain, on the key path.</li>


<li><strong>The 10,000-byte script size limit and the 201 non-push-opcode limit are gone.</strong> They are replaced by a per-input signature-operation budget that starts at 50 plus the serialized witness size and loses 50 for each executed signature opcode with a non-empty signature. Run out and validation fails.</li>


<li><strong>The stack limits stay.</strong> 1,000 elements combined across stack and altstack, 520 bytes per element. Removing the opcode cap did not remove the memory bound.</li>


<li><strong><code>OP_SUCCESSx</code> reserves opcode values for future soft forks.</strong> Encountering one in a valid Taproot script makes validation <em>succeed</em> before ordinary execution — including inside a branch that would not have run. That is an upgrade hook, and it is also why you should never accept a Taproot script you have not read.</li>


<li><strong>The annex exists.</strong> If the witness has at least two elements and the last one starts with <code>0x50</code>, it is stripped, counted toward weight, and committed to by the signature — otherwise ignored. Reserved space, currently unused.</li>

</ul>



<h2 class="wp-block-heading" id="so-when-do-you-actually-get-the-privacy">So, When Do You Actually Get the Privacy?</h2>



<p class="wp-block-paragraph">The honest answer is: only in the cooperative case, and only if everyone else also looks the same. Concretely:</p>



<ul class="wp-block-list">
<li><strong>Get the co-signers online.</strong> Every script-path spend publishes a leaf and a Merkle path forever. If your quorum rarely agrees, you paid for Taproot and will still show the world your tree.</li>


<li><strong>Put the common case at key path, the exceptions in the tree.</strong> A timelock recovery, an arbitration key, a hash-locked atomic swap — those belong in leaves precisely because they should almost never execute.</li>


<li><strong>Do not treat <code>bc1p</code> as a privacy flag.</strong> Its guarantee is that the <em>output</em> looks uniform. The graph around it is unchanged, and the moment you spend via script path, that leaf is public for the rest of the chain&#8217;s history.</li>


<li><strong>Count the cost honestly.</strong> Key path is the cheapest input Bitcoin has at roughly 57.5 vB. Script path with a depth-4 proof adds 128 bytes of control block plus the leaf. Both are cheaper than the 148 vB legacy equivalent — the privacy is a side effect of a fee optimization that happened to also be a good idea.</li>

</ul>



<p class="wp-block-paragraph">(The End)</p>
]]></content:encoded>
					
					<wfw:commentRss>https://www.newsbbvn.com/crypto/bitcoin/996.html/feed</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>311 Bytes: Reading a Bitcoin Transaction Field by Field</title>
		<link>https://www.newsbbvn.com/crypto/bitcoin/995.html</link>
					<comments>https://www.newsbbvn.com/crypto/bitcoin/995.html#respond</comments>
		
		<dc:creator><![CDATA[BBVN Research]]></dc:creator>
		<pubDate>Wed, 21 Oct 2026 05:52:44 +0000</pubDate>
				<category><![CDATA[Bitcoin]]></category>
		<category><![CDATA[bitcoin]]></category>
		<category><![CDATA[crypto]]></category>
		<guid isPermaLink="false">https://www.newsbbvn.com/markets/995.html</guid>

					<description><![CDATA[A Bitcoin transaction answers exactly three questions: which coins, to whom, and when it counts. Every byte maps to one of them. Here is the layout field by field, and why the same payment costs three different amounts.]]></description>
										<content:encoded><![CDATA[
<div class="k7hex">
<div class="k7-hex"><span class="k7-b">02</span><span class="k7-b">00</span><span class="k7-b">00</span><span class="k7-b">00</span><i class="k7-anno">version · 4 bytes · little-endian</i></div><p class="k7-hex-p">Four fields decide everything</p>
</div>



<p class="wp-block-paragraph">I spent an evening last week staring at raw transaction hex on a block explorer, zooming in until the browser stopped letting me, and the thing that struck me was not the cryptography. It was how <strong>boring</strong> the layout is. A Bitcoin transaction is a sequence of length-prefixed fields, written little-endian, with no compression, no cleverness, and no room for interpretation. You could parse it with a <code>while</code> loop and forty lines of Python.</p>



<p class="wp-block-paragraph">That boringness is the design. Every byte in that string is answering one of exactly three questions: <strong>which coins are being spent, where the new ones go, and when this becomes valid.</strong> If a field does not answer one of those, it is not there.</p>



<p class="wp-block-paragraph">So let me take one apart. Not conceptually — literally, in order, the way the parser sees it.</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1920" height="1234" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/tx-1.jpg" alt="A dense anatomical manuscript page — the original field-by-field reading" class="wp-image-986"/><figcaption class="wp-element-caption">Wellcome Collection, CC BY 4.0, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="the-container">The Container</h2>



<pre class="wp-block-code"><code>4 bytes    version          usually 0x00000002
varint     input count      how many coins are being spent
  ...      inputs
varint     output count
  ...      outputs
4 bytes    nLockTime</code></pre>



<p class="wp-block-paragraph"><code>version</code> is almost always <code>2</code> these days. That is not cosmetic: version 2 is what enables the <code>OP_CHECKSEQUENCEVERIFY</code> relative timelock, and a transaction that wants to use script-level time locks has to declare it up front. Version 1 still exists and still validates; it simply cannot do things version 2 can.</p>



<p class="wp-block-paragraph">The counts are varints, which is why small transactions look like they have almost no overhead: one byte for &#8220;2 inputs&#8221;, one byte for &#8220;2 outputs&#8221;.</p>



<h2 class="wp-block-heading" id="inside-an-input">Inside an Input</h2>



<p class="wp-block-paragraph">An input is the smallest possible statement of &#8220;I am spending that specific coin&#8221;:</p>



<pre class="wp-block-code"><code>36 bytes    prevout      32-byte txid + 4-byte vout index
varint      scriptSig length
  N bytes   scriptSig    unlocking script (often empty in SegWit)
4 bytes     nSequence</code></pre>



<p class="wp-block-paragraph">The 36-byte outpoint is worth pausing on. <strong>Bitcoin does not spend &#8220;from an address&#8221; and does not spend &#8220;a balance&#8221;.</strong> It names one specific output of one specific earlier transaction by its hash and its position in that transaction&#8217;s output list. That is the whole of it. This is why the <a href="/crypto/bitcoin/866.html">UTXO model</a> piece insists your balance is not a number — the number is a sum your wallet computed; the chain only knows outpoints.</p>



<p class="wp-block-paragraph"><code>scriptSig</code> is where the two eras of Bitcoin visibly split. In a legacy P2PKH spend, this field carries your signature and your public key, and it is part of the block&#8217;s base data. In a SegWit spend, this field is empty — the signature has moved out to a separate witness structure that is <strong>not counted at full weight</strong>. That single move is why the same payment got cheaper without changing the 1 MB block size people kept arguing about.</p>



<p class="wp-block-paragraph"><code>nSequence</code> is the field everybody ignores and shouldn&#8217;t:</p>



<p class="has-text-align-center wp-block-paragraph"><strong style="font-size:26px">0xffffffff</strong> — nSequence value that means &#8220;final&#8221; — it disables nLockTime and opts out of replacement</p>



<p class="has-text-align-center wp-block-paragraph"><code>sequence = 0xffffffff → final, no RBF · sequence &lt; 0xfffffffe → opt-in to BIP-125 replacement</code></p>



<p class="wp-block-paragraph">That is it. Two values out of four billion do all the work in practice. If you have ever wondered how a wallet &#8220;speeds up&#8221; a stuck transaction, this byte is the answer: the original transaction signaled replaceability with a sequence number below <code>0xfffffffe</code>, so a new version can reuse the same outpoints at a higher fee.</p>



<h2 class="wp-block-heading" id="inside-an-output">Inside an Output</h2>



<pre class="wp-block-code"><code>8 bytes     value        amount in satoshi
varint      scriptPubKey length
  N bytes   scriptPubKey the locking condition</code></pre>



<p class="wp-block-paragraph">Eight bytes for the amount. That is 18,446,744,073,709,551,615 satoshi of headroom, and the entire supply of bitcoin is 2,100,000,000,000,000 satoshi — less than 0.012% of what the field can express. There is no overflow risk here by luck; the field is simply absurdly oversized for the job.</p>



<p class="wp-block-paragraph">The <code>scriptPubKey</code> is the lock. For a modern single-key wallet it is 22 bytes (<code>OP_0</code> plus a 20-byte hash), for Taproot it is 34 bytes (<code>OP_1</code> plus a 32-byte x-only key), for an <code>OP_RETURN</code> output it is a provably unspendable data carrier and the value is zero.</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1400" height="2401" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/tx-2.jpg" alt="An early X-ray tube — the instrument that made internal structure readable" class="wp-image-994"/><figcaption class="wp-element-caption">Wellcome Collection, CC BY 4.0, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="why-the-same-payment-costs-three-different-amounts">Why the Same Payment Costs Three Different Amounts</h2>



<p class="wp-block-paragraph">Here is where the byte layout stops being trivia. A transaction&#8217;s cost is not measured in bytes. It is measured in <strong>weight</strong>, and weight treats the two halves of the transaction differently:</p>



<p class="has-text-align-center wp-block-paragraph"><code>weight = base_size × 4 + witness_size × 1 · vsize = ceil(weight / 4) · block cap = 4,000,000 WU</code></p>



<p class="wp-block-paragraph">So witness data is discounted to a quarter. A signature that would have cost 72 bytes of block space now costs 18 virtual bytes. And the practical consequence, for the same one-input two-output payment:</p>



<figure class="wp-block-table"><table><thead><tr><th>Spend type</th><th>What the input looks like</th><th>Rough input vsize</th></tr></thead><tbody><tr><td>P2PKH (legacy, <code>1...</code>)</td><td>sig + pubkey in scriptSig</td><td>~148 vB</td></tr><tr><td>P2WPKH (SegWit v0, <code>bc1q...</code>)</td><td>empty scriptSig, sig + pubkey in witness</td><td>~68 vB</td></tr><tr><td>P2TR key-path (<code>bc1p...</code>)</td><td>empty scriptSig, one 64-byte signature</td><td>~57.5 vB</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">Read that table again with fee rates attached. At 20 sat/vB, the legacy input costs about 2,960 satoshi and the Taproot input about 1,150. <strong>The format you receive to is a fee decision made months before you pay the fee.</strong> That is why the previous piece on <a href="/crypto/bitcoin/976.html">address formats</a> argued you should stop receiving to <code>1...</code> addresses — the bill is deferred, not avoided.</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1200" height="1601" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/tx-3.jpg" alt="A plate from Govard Bidloo's 1690 anatomical atlas, drawn by Gerard de Lairesse" class="wp-image-987"/><figcaption class="wp-element-caption">Gerard de Lairesse, Public domain, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="locktime-and-the-two-clocks">Locktime, and the Two Clocks</h2>



<p class="wp-block-paragraph">The last four bytes decide when the transaction is allowed to exist.</p>



<p class="wp-block-paragraph"><code>nLockTime</code> below 500,000,000 is read as a <strong>block height</strong>. At or above it, it is read as a <strong>Unix timestamp</strong>. That threshold is not arbitrary — it is <code>LOCKTIME_THRESHOLD</code>, and it means a locktime of 500,000,000 is the first value interpreted as a date (November 1985, which is why nobody accidentally sets it).</p>



<p class="wp-block-paragraph">And a locktime does nothing on its own. It only takes effect if at least one input&#8217;s <code>nSequence</code> is not final. This is the interaction that trips people up: <strong>you cannot have a timelocked transaction and a replaceable one using the same bytes in the same way</strong>, and a wallet that sets locktime while leaving every sequence at <code>0xffffffff</code> has written a field that the consensus rules will ignore.</p>



<h2 class="wp-block-heading" id="what-i-actually-take-from-this">What I Actually Take From This</h2>



<p class="wp-block-paragraph">The transaction format is 2009 engineering that has survived four major soft forks because it was <strong>explicit about every field</strong>. There is no extension mechanism inside the encoding, no optional headers, no versioned sub-structures. When Bitcoin needed new capability, it put it in a place the old format could not see — the witness — and then re-weighted the accounting around it.</p>



<p class="wp-block-paragraph">That is a very different design philosophy from &#8220;we&#8217;ll add a flags field and figure it out later.&#8221; It costs flexibility up front. It buys you a format that two independent implementations can parse identically fifteen years later, which is the only property that actually matters for a settlement layer.</p>



<p class="wp-block-paragraph">So, for what it&#8217;s worth:</p>



<ul class="wp-block-list">
<li><strong>If you are debugging a stuck transaction, look at <code>nSequence</code> first.</strong> Not the fee, not the mempool depth. A final sequence means no replacement is possible, and everything else follows from that.</li>


<li><strong>If you are estimating cost, estimate in weight, not bytes.</strong> The witness discount is a 4x factor and it dominates every other consideration at today&#8217;s fee levels.</li>


<li><strong>If a tool shows you an &#8220;amount sent&#8221; without showing the change output, it is guessing.</strong> The chain has outputs, not transfers; a payment and its change are the same kind of thing in the same list.</li>

</ul>



<p class="wp-block-paragraph">(The End)</p>
]]></content:encoded>
					
					<wfw:commentRss>https://www.newsbbvn.com/crypto/bitcoin/995.html/feed</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>One Seed, 2,147,483,648 Forks: How a Wallet Grows Every Key You Will Ever Use</title>
		<link>https://www.newsbbvn.com/crypto/bitcoin/977.html</link>
					<comments>https://www.newsbbvn.com/crypto/bitcoin/977.html#respond</comments>
		
		<dc:creator><![CDATA[BBVN Research]]></dc:creator>
		<pubDate>Tue, 20 Oct 2026 13:34:10 +0000</pubDate>
				<category><![CDATA[Bitcoin]]></category>
		<category><![CDATA[bitcoin]]></category>
		<category><![CDATA[crypto]]></category>
		<guid isPermaLink="false">https://www.newsbbvn.com/markets/977.html</guid>

					<description><![CDATA[Twelve words become an unlimited number of keys through HMAC-SHA512 and a 32-byte chain code. The 2^31 line splits hardened from normal derivation — and it is the reason a leaked child key can cost you an entire account.]]></description>
										<content:encoded><![CDATA[
<div class="k6gloss">
<table class="k6-gloss"><tbody><tr><th class="k6-gloss-k">2<sup>31</sup></th><td class="k6-gloss-v">The number that splits the tree</td></tr></tbody></table>
</div>



<p class="wp-block-paragraph">2,147,483,648. That is 2³¹, and it is the single most consequential number in wallet design. It is not a key length, not a block height, not a difficulty target. It is the line down the middle of the derivation tree: every index below it behaves one way, every index at or above it behaves another, and the difference between the two is the difference between &#8220;an auditor can watch my balances&#8221; and &#8220;an auditor can take my money.&#8221;</p>



<p class="wp-block-paragraph">You write down twelve words once. Your wallet then produces an effectively unlimited number of keys, in a reproducible order, forever. The interesting question is not how it does that — HMAC and some modular arithmetic, thirty lines of code. The interesting question is <strong>which parts of that tree you can hand to somebody else without handing them the tree.</strong></p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1920" height="1234" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/hd-1.jpg" alt="Tree roots spreading through soil — the shape of a derivation tree" class="wp-image-968"/><figcaption class="wp-element-caption">Grand Canyon NPS, Public domain, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="peeling-a-wallet-is-not-a-container">Peeling: A Wallet Is Not a Container</h2>



<p class="wp-block-paragraph">Start by throwing the word away. A wallet does not hold coins — nothing holds coins. What it holds is <strong>a recipe for generating keys</strong>, and the coins live on the chain, locked to those keys. <a href="/products/336.html">Your wallet never stored a coin</a> either; that was the point of that piece.</p>



<p class="wp-block-paragraph">Once you see the wallet as a key generator rather than a box, the design requirements become obvious:</p>



<ul class="wp-block-list">
<li><strong>Backup must be one-time.</strong> If every new address required a new backup, the scheme would fail on human nature within a month.</li>


<li><strong>Order must be deterministic.</strong> Two devices with the same seed must produce the same address #47, or recovery is a lottery.</li>


<li><strong>Some parts must be delegable.</strong> A shop server needs to generate <em>fresh receiving addresses</em> all day. It must be able to do that without the ability to spend anything.</li>

</ul>



<p class="wp-block-paragraph">Requirement 3 is where 2³¹ shows up, and it is the only one of the three that is genuinely hard.</p>



<h2 class="wp-block-heading" id="from-twelve-words-to-512-bits">From Twelve Words to 512 Bits</h2>



<div class="k6flow">
<ol class="k6-flow"><li><span class="k6-t">128 or 256 bits</span><p class="k6-d">Entropy is generated; 128 → 12 words, 256 → 24 words</p></li><li><span class="k6-t">+ checksum</span><p class="k6-d">The mnemonic gets its own checksum; a bad word fails locally</p></li><li><span class="k6-t">PBKDF2 × 2048</span><p class="k6-d">HMAC-SHA512, salt = &#8220;mnemonic&#8221; + optional passphrase → 512-bit seed</p></li><li><span class="k6-t">&#8220;Bitcoin seed&#8221;</span><p class="k6-d">I = HMAC-SHA512(key = &#8220;Bitcoin seed&#8221;, data = seed)</p></li><li><span class="k6-t">split I</span><p class="k6-d">Left 256 bits = master private key · right 256 bits = master chain code</p></li></ol>
</div>



<p class="wp-block-paragraph">Two things worth noticing there. The 2048 PBKDF2 rounds are not there to slow <em>you</em> down — they are there to make guessing passphrases expensive, because a wallet with a passphrase and a wallet without one are indistinguishable to anyone holding the twelve words.</p>



<p class="wp-block-paragraph">And the chain code is the part people forget. Every node in the tree carries <strong>two</strong> 256-bit values: a key and a chain code. The key is what you spend with. The chain code is what makes the child derivation <em>unpredictable to anyone who only has the key</em>. Without it, derivation would be a function of the parent key alone, and everyone who ever saw one of your addresses could compute the rest of your branch.</p>



<h2 class="wp-block-heading" id="the-fork-in-the-road">The Fork in the Road</h2>



<p class="wp-block-paragraph">Here is the entire child derivation, in the two cases that matter:</p>



<pre class="wp-block-code"><code>def ckd(parent_key, parent_chaincode, index, is_private):
    if index &gt;= 2**31:                       # hardened
        data = b"\x00" + ser256(parent_priv) + ser32(index)
    else:                                    # normal
        data = serP(pubkey_from(parent_priv)) + ser32(index)
    IL, IR = HMAC_SHA512(parent_chaincode, data)[:32], [32:]
    child_priv = (parse256(IL) + parent_priv) % n
    return child_priv, IR</code></pre>



<p class="wp-block-paragraph">Read those two <code>data</code> lines again, because everything follows from them.</p>



<p class="wp-block-paragraph"><strong>Non-hardened</strong> uses the parent <em>public</em> key as input. Which means: if you have the parent&#8217;s extended public key — its public key plus its chain code — you can compute every child&#8217;s <code>IL</code>, and therefore every child <strong>public</strong> key and address, without knowing any private key at all. That is the feature. It is the whole reason &#8220;watch-only&#8221; works.</p>



<p class="wp-block-paragraph"><strong>Hardened</strong> uses the parent <em>private</em> key as input, prefixed with a zero byte. No amount of public information will get you there. That is the wall.</p>



<p class="wp-block-paragraph">The price of the first one is arithmetic, and it is brutal:</p>



<p class="has-text-align-center wp-block-paragraph"><code>k_child = (IL + k_parent) mod n · IL is computable from the xpub alone → k_parent = k_child − IL</code></p>



<p class="wp-block-paragraph"><strong>That is the attack.</strong> Hand me your account-level extended public key, and let me obtain <em>any single non-hardened child private key</em> — from one leaked key, one bad export, one device that logged it — and I subtract. Out falls the parent private key. From the parent private key I recompute every sibling, because every sibling&#8217;s <code>IL</code> was computable from the xpub I already had.</p>



<p class="wp-block-paragraph">One child key is not one key compromised. <strong>It is the whole account.</strong></p>



<div class="wp-block-getwid-icon-box has-text-left has-background" style="background-color:#fbfcfd;padding:18px;border-radius:10px">
<div class="wp-block-getwid-icon-box__icon-container is-position-top"><div class="wp-block-getwid-icon-box__icon-wrapper" style="font-size:24px"><i class="fas fa-shield-halved" aria-hidden="true"></i></div></div>
<div class="wp-block-getwid-icon-box__content">
<h4 class="wp-block-heading">Hardened derivation is not secrecy</h4>
<p>It does not hide the child from anyone. Every address is on a public blockchain. What it does is cut the arithmetic link backwards: there is no formula from a child private key to its parent, because the input to that step was the parent&#8217;s private key.</p>
</div>
</div>



<div class="wp-block-getwid-icon-box has-text-left has-background" style="background-color:#fbfcfd;padding:18px;border-radius:10px">
<div class="wp-block-getwid-icon-box__icon-container is-position-top"><div class="wp-block-getwid-icon-box__icon-wrapper" style="font-size:24px"><i class="fas fa-sitemap" aria-hidden="true"></i></div></div>
<div class="wp-block-getwid-icon-box__content">
<h4 class="wp-block-heading">The wall is placed by convention, not by physics</h4>
<p>Nothing in BIP-32 forces the first three levels to be hardened. It is the path standards — BIP-44, BIP-49, BIP-84, BIP-86 — that put <code>'</code> on purpose, coin type and account, and leave change and index soft so a watch-only server can still do its job.</p>
</div>
</div>



<div class="wp-block-getwid-icon-box has-text-left has-background" style="background-color:#fbfcfd;padding:18px;border-radius:10px">
<div class="wp-block-getwid-icon-box__icon-container is-position-top"><div class="wp-block-getwid-icon-box__icon-wrapper" style="font-size:24px"><i class="fas fa-file-export" aria-hidden="true"></i></div></div>
<div class="wp-block-getwid-icon-box__content">
<h4 class="wp-block-heading">An xpub is a read credential with a sharp edge</h4>
<p>It grants full visibility into every address that branch will ever produce. That is genuinely useful and genuinely dangerous in the same gesture. Treat it like a password you intend to publish.</p>
</div>
</div>



<h2 class="wp-block-heading" id="what-a-path-actually-says">What a Path Actually Says</h2>



<p class="wp-block-paragraph"><code>m/84'/0'/0/0/0</code> is not an opaque string. It reads left to right as a set of five decisions:</p>



<figure class="wp-block-table"><table><thead><tr><th>Segment</th><th>Value</th><th>Means</th></tr></thead><tbody><tr><td><code>m</code></td><td>—</td><td>Master node, derived from the seed</td></tr><tr><td>purpose</td><td><code>84'</code></td><td>Use native SegWit (bech32) addresses</td></tr><tr><td>coin type</td><td><code>0'</code></td><td>Bitcoin (not testnet, not another chain)</td></tr><tr><td>account</td><td><code>0'</code></td><td>Account zero; your first independent bucket</td></tr><tr><td>change</td><td><code>0</code></td><td>External chain — addresses you show people</td></tr><tr><td>index</td><td><code>0</code></td><td>The first address in that chain</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">The three apostrophes are the hardened levels. The last two are not, and that is deliberate: exporting the account-level xpub (<code>m/84'/0'/0'</code>) gives a server everything it needs to generate receiving addresses for the rest of time, while the hardened wall at account level means a leaked address key stops at the account boundary instead of climbing the tree.</p>



<p class="wp-block-paragraph">Change the <code>84'</code> and you get a different address <em>family</em> from the same seed: <code>44'</code> for legacy <code>1...</code>, <code>49'</code> for <code>3...</code>, <code>86'</code> for Taproot <code>bc1p</code>. <strong>Same twelve words, four wallets that do not see each other.</strong> That is the most common way people conclude their recovery &#8220;didn&#8217;t work&#8221; — the seed was fine, the path was different.</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1400" height="933" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/hd-2.jpg" alt="An open drawer of a card catalog, each card an index into something larger" class="wp-image-969"/><figcaption class="wp-element-caption">Michael Holley Swtpc6800, Public domain, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="the-78-bytes-you-are-actually-exporting">The 78 Bytes You Are Actually Exporting</h2>



<p class="wp-block-paragraph">An extended key is a fixed structure, and it is worth knowing what is in it:</p>



<pre class="wp-block-code"><code>4 bytes   version          xprv 0x0488ADE4 · xpub 0x0488B21E
1 byte    depth            0x00 for master, +1 per level
4 bytes   parent fingerprint   first 4 bytes of the parent's Hash160
4 bytes   child number     the index, hardened flag included in the high bit
32 bytes  chain code       the entropy that makes derivation one-way
33 bytes  key data         0x00 + privkey, or the compressed pubkey
= 78 bytes → Base58Check → 111 characters starting with "xprv" or "xpub"</code></pre>



<p class="wp-block-paragraph">The fingerprint is the detail I would underline. It is four bytes — a <em>heuristic</em>, not a proof. The spec says so explicitly: implementations must tolerate collisions. Software that treats a matching fingerprint as cryptographic evidence of parentage is doing something the standard never promised.</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1400" height="1050" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/hd-3.jpg" alt="A skeleton key, the kind made to open many locks rather than one" class="wp-image-970"/><figcaption class="wp-element-caption">Blenheimears, CC0, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="diagnosis">Diagnosis</h2>



<p class="wp-block-paragraph">The mental model to walk away with: <strong>a seed is a tree, an xpub is a branch, and the branch is only safe to hand out because somebody put a wall at the account level.</strong> The wall is 2³¹. Everything below it is visible and derivable from public data; everything at or above it requires the private key that produced it.</p>



<p class="wp-block-paragraph"><strong>Ruled out:</strong> that hardening hides anything (it does not, the chain is public); that a leaked child key costs one key (it costs the account, if that child was below the wall); that a wrong-path recovery means a wrong seed (usually the path, not the seed).</p>



<p class="wp-block-paragraph"><strong>What would change my mind:</strong> a wallet that exports non-hardened keys above the account level, or one that treats a parent fingerprint as proof. Both are bugs, and neither is exotic.</p>



<p class="wp-block-paragraph">(The End)</p>
]]></content:encoded>
					
					<wfw:commentRss>https://www.newsbbvn.com/crypto/bitcoin/977.html/feed</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>The Last Six Characters: What a Bitcoin Address Actually Checks</title>
		<link>https://www.newsbbvn.com/crypto/bitcoin/976.html</link>
					<comments>https://www.newsbbvn.com/crypto/bitcoin/976.html#respond</comments>
		
		<dc:creator><![CDATA[BBVN Research]]></dc:creator>
		<pubDate>Tue, 20 Oct 2026 13:34:01 +0000</pubDate>
				<category><![CDATA[Bitcoin]]></category>
		<category><![CDATA[bitcoin]]></category>
		<category><![CDATA[crypto]]></category>
		<guid isPermaLink="false">https://www.newsbbvn.com/markets/976.html</guid>

					<description><![CDATA[The final six characters of a bech32 address are the only thing standing between a typo and coins nobody can spend. Base58Check could only say no; bech32's BCH checksum can find the error. And bech32 had a hole, fixed by changing one constant.]]></description>
										<content:encoded><![CDATA[
<div class="k6code">
<div class="k6-decode"><code class="k6-addr">bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4</code><span class="k6-tail">last 6 characters = checksum</span></div><p class="k6-decode-b">Two envelopes, one checksum</p>
</div>



<p class="wp-block-paragraph">I have a bad habit of reading addresses backwards. Not the whole thing — just the tail. <code>...vary0c5xw7kv8f3t4</code>. Six characters at the end of a Bitcoin address that I cannot decode, cannot verify by eye, and have never once thought about, right up until the moment a wallet refuses a paste and I have to.</p>



<p class="wp-block-paragraph">Here is what those six characters are: the only thing in the entire system that stands between a typo and a pile of coins that nobody can ever spend. Not the network. Not the miners. Not the confirmations. <strong>Once the transaction is broadcast, there is no address to complain to.</strong> There is no &#8220;wrong address&#8221; desk. If the string you sent to happens to be a <em>valid</em> address, the coins are gone to whoever holds that key, and the blockchain did its job perfectly.</p>



<p class="wp-block-paragraph">So the checksum is not a formatting detail. It is the last checkpoint, and it runs on your machine, before anything leaves it. And — this is the part I did not know until I went and read the two BIPs side by side — that checksum had a hole in it. Somebody found the hole before it cost anybody money, and fixed it by changing <strong>one number</strong>.</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1920" height="1234" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/addr-1.jpg" alt="The mail sorting room of the U.S. Post Office in Washington, D.C., where an address is read and routed" class="wp-image-966"/><figcaption class="wp-element-caption">National Photo Company Collection, Public domain, via Wikimedia Commons</figcaption></figure>



<p class="wp-block-paragraph"><em>Bitcoin addresses are not accounts. Nothing on the chain holds a balance under your name — what exists is a set of locked outputs, and an address is just a compact way of writing the lock. If that distinction feels slippery, the <a href="/crypto/bitcoin/866.html">UTXO model</a> piece goes through it properly.</em></p>



<h2 class="wp-block-heading" id="the-two-analogies-i-use">The Two Analogies I Use</h2>



<p class="wp-block-paragraph">An address is easier to hold in your head if you think of it as <strong>a postal address with a national prefix</strong>, and the checksum as <strong>the check digit on a barcode</strong>. Both analogies have teeth, and each one explains a different thing.</p>



<p class="wp-block-paragraph"><strong>Postal first.</strong> A Bitcoin address has a human-readable part — <code>bc</code> on mainnet, <code>tb</code> on testnet — followed by a separator <code>1</code>, followed by the payload. <code>bc1q...</code>. That is <code>bc</code> + <code>1</code> + data. The prefix tells you which system this address belongs to before you look at a single payload character, the same way <code>US</code> or <code>JP</code> at the top of an envelope tells a sorting machine which country&#8217;s rules apply. It is why a testnet address pasted into a mainnet field gets caught by software rather than by luck.</p>



<p class="wp-block-paragraph"><strong>Barcode second.</strong> The last six characters are computed from everything before them. Change one character anywhere in the middle and the six characters at the end stop matching. That is the same idea as the final digit on a barcode or a credit card number: it is not security, anyone can recompute it, and it detects <strong>mistakes</strong>, not attackers. A checksum cannot tell you the address belongs to the person you think it does. It can only tell you that you copied it correctly.</p>



<p class="has-text-align-center wp-block-paragraph"><code>address = prefix + separator + payload + checksum ·  the last 6 characters are a function of everything before them</code></p>



<h2 class="wp-block-heading" id="base58check-four-bytes-that-can-only-say-no">Base58Check: Four Bytes That Can Only Say No</h2>



<p class="wp-block-paragraph">The old format — the <code>1...</code> and <code>3...</code> addresses — works like this. You take a version byte (<code>0x00</code> for pay-to-public-key-hash, which renders as a leading <code>1</code>; <code>0x05</code> for pay-to-script-hash, which renders as <code>3</code>), append the 20-byte hash, append four bytes of <code>SHA256(SHA256(...))</code>, and base58-encode the lot.</p>



<p class="wp-block-paragraph">Four bytes. About 1 in 4.3 billion chance that a mangled address still validates. That sounds reassuring until you notice what it <em>doesn&#8217;t</em> do:</p>



<p class="has-text-align-center wp-block-paragraph"><strong style="font-size:26px">4 · 42 · 90</strong> — bytes of Base58Check checksum · characters in a bech32 P2WPKH address · the 90-character bech32 cap</p>



<ul class="wp-block-list">
<li><strong>It cannot tell you where the error is.</strong> A failed double-SHA256 check means &#8220;somewhere in there, something is wrong.&#8221; It does not mean &#8220;character 19.&#8221;</li>


<li><strong>It cannot fix it.</strong> Error <em>correction</em> is a property you cannot bolt onto a hash. The hash destroys the information you would need to recover the original.</li>


<li><strong>The alphabet is the enemy.</strong> Base58 keeps digits and letters but drops <code>0</code>, <code>O</code>, <code>I</code> and <code>l</code>, precisely because humans confuse them. That is a band-aid on a format where a single character substitution produces a different, perfectly valid address.</li>

</ul>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1400" height="1844" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/addr-2.jpg" alt="A street mail box in Alhama de Granada, Spain — the physical endpoint of an address" class="wp-image-975"/><figcaption class="wp-element-caption">CC0, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="bech32-a-checksum-that-can-actually-find-the-typo">Bech32: A Checksum That Can Actually Find the Typo</h2>



<p class="wp-block-paragraph">Bech32 (BIP-173) throws the hash out and uses a <strong>BCH code over GF(32)</strong> instead. Six characters, same length, but a completely different animal.</p>



<p class="wp-block-paragraph">The alphabet is <code>qpzry9x8gf2tvdw0s3jn54khce6mua7l</code>. Thirty-two characters. Note which ones are missing: <code>1</code>, <code>b</code>, <code>i</code>, <code>o</code>. The <code>1</code> is excluded because it is doing double duty as the separator; the other three because they are the ones people misread aloud. The whole string must be one case — all lower or all upper, never mixed — and that is deliberate: uppercase lets a QR encoder drop into alphanumeric mode and produce a materially smaller code.</p>



<p class="wp-block-paragraph">What you get in exchange is a checksum that can detect <strong>up to four character errors</strong>, and, unlike a hash, one that has enough structure to be used for locating them. The spec caps the total at 90 characters.</p>



<pre class="wp-block-code"><code>def bech32_checksum(hrp, data, const):
    # const = 1 for bech32 (witness v0) · 0x2bc830a3 for bech32m (v1+)
    polymod = bech32_polymod(hrp_expand(hrp) + data + [0] * 6) ^ const
    return [(polymod &gt;&gt; 5 * (5 - i)) &amp; 31 for i in range(6)]
# that single XOR is the entire difference between bc1q and bc1p</code></pre>



<div class="k6trade">
<div class="k6-trade"><div class="k6-line"><span class="k6-who">Base58Check, on a typo</span><p class="k6-said">Something in here is wrong. I can&#8217;t tell you where.</p></div><div class="k6-line"><span class="k6-who">Bech32, on the same typo</span><p class="k6-said">Up to four errors, and I can point at them.</p></div><div class="k6-line"><span class="k6-who">You, holding a rejected paste</span><p class="k6-said">Only one of these two can tell me where to look.</p></div></div>
</div>



<h2 class="wp-block-heading" id="the-hole-and-the-number-that-closed-it">The Hole, and the Number That Closed It</h2>



<p class="wp-block-paragraph">This is the part I think everybody who writes about address formats skips, and it is the best story in the whole specification.</p>



<p class="wp-block-paragraph">Bech32&#8217;s checksum has a known weakness: <strong>if the last character of the address is a <code>p</code>, then inserting or deleting any number of <code>q</code> characters immediately before it leaves the checksum valid.</strong> Not &#8220;might&#8221; — does. It comes out of how the polymod interacts with the constant used to finalize the checksum.</p>



<p class="wp-block-paragraph">Witness version 0 addresses dodged this by accident. P2WPKH is always 42 characters and P2WSH is always 62, so an insertion or deletion fails the length check before it can do any damage. <strong>The length was doing the work, not the checksum.</strong> That protection evaporated the moment anyone wanted a witness program of variable length — which is exactly what witness version 1 and above wanted.</p>



<p class="wp-block-paragraph">BIP-350 fixes it by changing one number. The final XOR constant goes from <code>1</code> to <code>0x2bc830a3</code>. Every other line of the algorithm is untouched.</p>



<p class="has-text-align-center wp-block-paragraph"><code>bech32 → constant 1 · bech32m → constant 0x2bc830a3 · witness v0 → bech32 · witness v1+ → bech32m</code></p>



<p class="wp-block-paragraph">The two variants are <strong>deliberately incompatible</strong>. A bech32 string will not validate as bech32m and vice versa. That is not an oversight; it is the point. Software that does not know about bech32m fails <em>closed</em> — it refuses an address it does not understand, rather than cheerfully encoding a Taproot output it has no business producing.</p>



<p class="wp-block-paragraph">I like this fix a lot. It is the kind of engineering I respect: someone sat down, found a defect in a checksum that had not yet cost anyone a satoshi, and the entire patch was a constant. No new field, no version negotiation, no flag day.</p>



<figure class="wp-block-table"><table><thead><tr><th>Format</th><th>Looks like</th><th>Checksum</th><th>Error handling</th><th>Use it?</th></tr></thead><tbody><tr><td>Base58Check P2PKH</td><td><code>1...</code></td><td>4 bytes, double-SHA256</td><td>Detect only, no location</td><td>No — legacy</td></tr><tr><td>Base58Check P2SH</td><td><code>3...</code></td><td>4 bytes, double-SHA256</td><td>Detect only, no location</td><td>Only for old counterparties</td></tr><tr><td>Bech32</td><td><code>bc1q...</code></td><td>6 chars, BCH over GF(32)</td><td>Up to 4 errors, locatable</td><td>Yes</td></tr><tr><td>Bech32m</td><td><code>bc1p...</code></td><td>6 chars, constant changed</td><td>Same, no <code>p</code>/<code>q</code> hole</td><td>Yes</td></tr></tbody></table></figure>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1400" height="933" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/addr-3.jpg" alt="A row of mailboxes, the physical endpoint of every address" class="wp-image-967"/><figcaption class="wp-element-caption">cogdogblog, CC BY 2.0, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="what-this-means-when-you-actually-send-something">What This Means When You Actually Send Something</h2>



<p class="wp-block-paragraph">None of the above will recover coins sent to a valid address that is not the recipient&#8217;s. That failure mode exists; the checksum does not address it and cannot. What the checksum does is narrow the field to a single class of error — &#8220;you typed it wrong&#8221; — and catch that class locally, on your machine, before broadcast.</p>



<p class="wp-block-paragraph">So, concretely:</p>



<ul class="wp-block-list">
<li><strong>Receive to <code>bc1q</code> or <code>bc1p</code>.</strong> Not for the fee discount (though there is one), but because those formats have a checksum that can find a typo instead of just rejecting it.</li>


<li><strong>Stop receiving to <code>1...</code> and <code>3...</code>.</strong> They exist for compatibility with software that should have been updated years ago. Every coin parked in one is a fee bill deferred, not avoided.</li>


<li><strong>Never retype an address.</strong> Paste it. If you are retyping, you are relying on a checksum to catch a class of error you could have simply not made.</li>


<li><strong>If a wallet rejects a <code>bc1p</code> address, that is information.</strong> In 2026 that wallet does not implement BIP-350. The network has understood it since 2021; the program in front of you is telling you how much attention its engineering gets.</li>

</ul>



<p class="wp-block-paragraph">The last six characters are boring on purpose. Boring is what you want from the thing standing between a paste and a permanent loss.</p>



<p class="wp-block-paragraph">(The End)</p>
]]></content:encoded>
					
					<wfw:commentRss>https://www.newsbbvn.com/crypto/bitcoin/976.html/feed</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>300 MB, 336 Hours, No Queue: What the Bitcoin Mempool Actually Is</title>
		<link>https://www.newsbbvn.com/crypto/bitcoin/945.html</link>
					<comments>https://www.newsbbvn.com/crypto/bitcoin/945.html#respond</comments>
		
		<dc:creator><![CDATA[BBVN Research]]></dc:creator>
		<pubDate>Sun, 18 Oct 2026 13:53:51 +0000</pubDate>
				<category><![CDATA[Bitcoin]]></category>
		<category><![CDATA[bitcoin]]></category>
		<category><![CDATA[crypto]]></category>
		<guid isPermaLink="false">https://www.newsbbvn.com/markets/945.html</guid>

					<description><![CDATA[There is no global mempool. Every node keeps its own candidate list, -minrelaytxfee went from 1 sat/vB to 0.1 in Core 30.0, eviction scores packages by descendant feerate while miners select by ancestor feerate, and nothing can cancel a transaction you already broadcast.]]></description>
										<content:encoded><![CDATA[
<div class="k5tube">
<p class="k5-eyebrow">THREE DOORS A TRANSACTION HAS TO GET THROUGH</p>
<div class="k5-tube"><div class="k5-band" style="width:100%"><span class="k5-band-l">relay policy</span><span class="k5-band-w"></span></div>
<div class="k5-band" style="width:72%"><span class="k5-band-l">each node&#8217;s mempool</span><span class="k5-band-w"></span></div>
<div class="k5-band" style="width:44%"><span class="k5-band-l">block template</span><span class="k5-band-w"></span></div></div>
<p class="k5-dek">A default node holds 300 MB of unconfirmed transactions before it starts throwing them away, and after 336 hours it forgets you ever paid, at any fee rate. Neither number describes a queue: every node keeps its own candidate list, its operator sets the thresholds, and miners answer to none of them. This piece follows one transaction along its whole path and names, at each door, who may decide and who has no standing to.</p>
</div>



<h2 class="wp-block-heading" id="300-mb-336-hours-and-no-queue-to-stand-in">300 MB, 336 Hours, and No Queue to Stand In</h2>



<p class="wp-block-paragraph">A default Bitcoin Core node keeps <strong>300 MB</strong> of unconfirmed transactions, and when the pool crosses that line it does not slow down or ask anybody — it finds the cheapest package it holds and deletes it whole. The other number is <strong>336 hours</strong>: when that deadline passes the node drops your transaction, and no fee rate is high enough to buy an exemption. Paying more does not make you permanent. It makes you expensive and, eventually, forgotten.</p>



<p class="wp-block-paragraph">Both are parameters, not physics. <code>-maxmempool</code> defaults to 300 MB and can be configured down to 5 MB; a node run with <code>-blocksonly</code> never keeps more than 5 MB, its operator having opted out of the waiting-room business. <code>-mempoolexpiry</code> is 336 hours, and <strong>in practice most expired transactions get rebroadcast by the wallet that cares</strong> — the network has no memory, the sender usually does.</p>



<p class="wp-block-paragraph">The waiting room is finite, local, and run by a stranger who owes you nothing.</p>



<h2 class="wp-block-heading" id="there-ain-t-no-such-thing-as-a-global-mempool">There Ain&#8217;t No Such Thing as a Global Mempool</h2>



<p class="wp-block-paragraph">The Bitcoin Core community has a fixed phrase for this: <strong>&#8220;There ain&#8217;t no such thing as a global mempool.&#8221;</strong> Every full node maintains its own, nothing forces two to converge, and they can stay different indefinitely — agreeing about unconfirmed transactions is not part of the job.</p>



<p class="wp-block-paragraph">This is the load-bearing claim of the piece, in the form that is useful: <strong>&#8220;the mempool&#8221; is not a queue — it is one candidate list per node, and a fee does not buy you a position in a line but a good rank each time an individual miner independently sorts his own list.</strong></p>



<div class="k5cards">
<div class="k5-cards"><div class="k5-card"><span class="k5-card-n">300 MB</span><span class="k5-card-t">default cap</span><p>what a node keeps before it starts throwing packages away</p></div><div class="k5-card"><span class="k5-card-n">336 h</span><span class="k5-card-t">the expiry</span><p>after this a node forgets you paid anything at all</p></div><div class="k5-card"><span class="k5-card-n">25</span><span class="k5-card-t">ancestor limit</span><p>how many unconfirmed parents one chain of transactions may have</p></div></div>
</div>



<p class="wp-block-paragraph">The consequences are not academic:</p>



<ul class="wp-block-list">
<li>A block explorer shows one node&#8217;s mempool, or a merge of a handful. A sample, not a census.</li>


<li>A transaction can be refused by every node you can reach and still be mined, if the miner heard of it elsewhere.</li>


<li>A transaction can be held by every node you can reach and still never be mined.</li>

</ul>



<p class="wp-block-paragraph">Internalize that last pair and most &#8220;why is my transaction stuck&#8221; questions answer themselves: the asker is imagining a single queue.</p>



<h2 class="wp-block-heading" id="door-one-policy-is-not-consensus">Door One: Policy Is Not Consensus</h2>



<p class="wp-block-paragraph">The first door is not the pool but a bouncer in front of it, and he works from a rulebook that is not the consensus rules. A transaction can be legal, correctly signed and spend valid outputs, and still be refused — not relayed, not stored — purely because of that node&#8217;s <strong>policy</strong>.</p>



<p class="wp-block-paragraph">Here is the part people get wrong in both directions: <strong>the moment a miner puts it into a valid block, every node accepts the block, and the policy objection dies.</strong> Policy governs what is unconfirmed and nothing that is confirmed. The severity difference is the point: violating a consensus rule makes the block invalid, network-wide, forever, while violating a policy rule only means this node won&#8217;t accept it or relay it. Different categories of failure, not degrees of it.</p>



<p class="wp-block-paragraph">Bitcoin Core caps a standard transaction at <strong>400,000 weight units (roughly 100,000 vbytes)</strong>, and that ceiling is nowhere in the consensus rules. Dust works the same way: <code>DUST_RELAY_TX_FEE</code>, <strong>3,000 sat/kvB</strong>, defines what output is too small to be worth writing into the UTXO set. The reasoning sits in <a href="https://www.newsbbvn.com/crypto/bitcoin/866.html">UTXO versus the account model</a>; the principle is that <strong>the UTXO set is a global cost paid forever, so policy charges for it at the door.</strong></p>



<pre class="wp-block-code"><code>-minrelaytxfee=100        # sat/kvB, the admission fee rate (0.1 sat/vB)
-maxmempool=300           # MB, the size of the waiting room
-mempoolexpiry=336        # hours, after which nothing survives
-limitancestorcount=25    # unconfirmed ancestors, itself included
-datacarriersize=83       # bytes; the old default for a data carrier output</code></pre>



<p class="wp-block-paragraph">Defaults are people. Core 30.0 (October 2025) raised the default cap on a single data carrier output from <strong>83 bytes to 100,000 bytes</strong>, keeping <code>-datacarriersize=83</code> for operators who wanted the old behaviour. The argument ended in a relay policy statement signed by <strong>31 contributors</strong> — about relay policy, never consensus. Bitcoin Knots ships deliberately stricter defaults, and that is a choice, not a fork. When someone says &#8220;Bitcoin doesn&#8217;t allow X,&#8221; make them say whether they mean consensus or one implementation&#8217;s default.</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1280" height="960" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/k5-pool-2.jpg" alt="A letter-sorting hall in a postal centre" class="wp-image-937"/><figcaption class="wp-element-caption">Hadi, CC0, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="door-two-100-sat-kvb-and-25-relatives">Door Two: 100 sat/kvB and 25 Relatives</h2>



<p class="wp-block-paragraph">Admission has a price, and the price is a default. <code>-minrelaytxfee</code> is <strong>100 sat/kvB (0.1 sat/vB)</strong>, and it used to be ten times that — <strong>1,000 sat/kvB (1 sat/vB)</strong> — until Core 30.0 shipped in October 2025. Years of &#8220;the minimum is 1 sat/vB&#8221; folk knowledge became wrong on a release date, not by consensus change.</p>



<p class="wp-block-paragraph">Fee rate is not the only shape limit here. A transaction may not drag an arbitrarily long tail of unconfirmed relatives into the pool: <code>DEFAULT_ANCESTOR_LIMIT</code> and <code>DEFAULT_DESCENDANT_LIMIT</code> are <strong>25 each, itself included</strong>, with a size ceiling of <strong>101 kvB</strong>. The purpose is DoS resistance — otherwise someone could force every node to redo unbounded work each time a new link arrives.</p>



<p class="wp-block-paragraph">Recent versions switch the unit to <strong>clusters</strong>: <code>DEFAULT_CLUSTER_LIMIT</code> is <strong>64 transactions</strong>, <code>DEFAULT_CLUSTER_SIZE_LIMIT_KVB</code> is <strong>101 kvB</strong>. I won&#8217;t claim the old counting is gone, since the ancestor limits still ship as defaults — but the direction matches everything else here: <strong>an operator chooses, for his own machine, what shapes of unconfirmed transaction graph he will hold.</strong></p>



<h2 class="wp-block-heading" id="door-three-eviction-is-a-descendant-feerate-contest">Door Three: Eviction Is a Descendant-Feerate Contest</h2>



<p class="wp-block-paragraph">The pool is full. What gets thrown out? Not the oldest, and not the absolutely cheapest. <code>TrimToSize</code> finds the <strong>descendant package with the lowest combined feerate and deletes the whole package</strong> — the transaction plus everything in the pool that spends from it.</p>



<p class="wp-block-paragraph">Then the node raises its own floor: after an eviction, <code>mempoolminfee</code> becomes the evicted package&#8217;s feerate <strong>plus <code>-incrementalrelayfee</code></strong> (default <strong>100 sat/kvB</strong>), and decays over time. That increment is not decoration — without it the evicted transaction walks back in at the same rate and gets evicted again, forever. The floor always sits above <code>-minrelaytxfee</code>, never below.</p>



<p class="wp-block-paragraph"><strong>Send at a marginally competitive rate and the node does not hold you &#8220;a bit longer&#8221; — it holds you until the room gets crowded, then deletes you first and charges more for readmission.</strong> The tail risk of frugality is not a delay. It is a deletion.</p>



<h2 class="wp-block-heading" id="door-four-the-miner-sorts-by-ancestor-feerate">Door Four: The Miner Sorts by Ancestor Feerate</h2>



<p class="wp-block-paragraph">Elsewhere a miner builds a block template. He is not reading your node&#8217;s mempool and is not bound by your node&#8217;s policy; if he heard of a transaction directly, he can include it even though every relay node refused it.</p>



<p class="wp-block-paragraph">He sorts by <strong>ancestor feerate</strong>: a transaction plus its unconfirmed ancestors, scored as combined fee over combined size. That is why chains score as units rather than links, and it is the opposite aggregation direction from eviction.</p>



<pre class="wp-block-code"><code>for cluster in mempool_clusters_sorted_by_feerate_desc:
    if ancestor_feerate(cluster) <= 0: continue
    if template_size + cluster.size > block_limit: continue
    if cluster.ancestor_count > 25 or cluster.size_kvb > 101: continue
    template.add(cluster)   # ancestors are pulled in as one unit</code></pre>



<p class="wp-block-paragraph">That pseudocode is a simplification — real template construction works over a linearized cluster ordering. But the load-bearing part is real, and it is what people miss: <strong>the unit of selection is a package, not a transaction, and the score is a ratio, not a fee.</strong> A large transaction with a large absolute fee loses to a small one with a better ratio, every time. Once the template is full, <a href="https://www.newsbbvn.com/crypto/bitcoin/340.html">how Bitcoin mining works</a> takes over.</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1280" height="916" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/k5-pool-3.jpg" alt="An intermodal container terminal" class="wp-image-938"/><figcaption class="wp-element-caption">Wikideas1, CC0, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="door-five-a-block-arrives-or-336-hours-pass">Door Five: A Block Arrives, or 336 Hours Pass</h2>



<p class="wp-block-paragraph">At this door the transaction either gets into a block or it doesn&#8217;t, and the dominant variable is not money. It is luck.</p>



<p class="wp-block-paragraph"><strong>Ten minutes is an average, not a metronome.</strong> A slow stretch stacks the same demand behind fewer blocks; a fast stretch hands out confirmations nobody paid for. Your fate is decided by when blocks land relative to when you broadcast, and no fee influences that. The machinery pulling the average back toward ten minutes is the <a href="https://www.newsbbvn.com/crypto/bitcoin/934.html">difficulty adjustment</a>.</p>



<p class="wp-block-paragraph">That is also why fee estimation is hard in a way no amount of engineering fixes. <strong>Estimation is not a table lookup — it is a prediction of what strangers will bid for the next few blocks, and that demand is not observable in advance.</strong> Core&#8217;s estimator watches how long transactions in each fee rate bucket historically took to confirm, across three timescales, and reports a rate that used to work. Saved estimates <strong>expire after 60 hours</strong>. When your wallet prints &#8220;confirms within 1 block,&#8221; it has rounded a probability distribution into a promise without telling you.</p>



<p class="wp-block-paragraph">If the blocks don&#8217;t arrive first, the transaction hits 336 hours and is dropped regardless of fee rate. Most wallets rebroadcast it — which is why &#8220;my transaction disappeared&#8221; usually resolves itself, and why the disappearance was never a cancellation.</p>



<h2 class="wp-block-heading" id="changing-your-mind-rbf-cpfp-and-a-race-you-cannot-win-by-dec">Changing Your Mind: RBF, CPFP, and a Race You Cannot Win by Declaring</h2>



<p class="wp-block-paragraph">People want a cancel button. There isn&#8217;t one, and the two substitutes have specific owners.</p>



<p class="wp-block-paragraph"><strong>Replace-by-fee</strong> began as opt-in. BIP 125 let a transaction announce its own replaceability with an input <code>nSequence</code> below <code>0xfffffffe</code>, and shipped in Core <strong>0.12.0 (February 2016)</strong>. Full RBF, needing no flag, became default in <strong>Core 28.0 (October 2024)</strong>, and <strong>29.0 deleted the switch that turned it off</strong>. A wallet saying its transactions can&#8217;t be replaced is describing an old default, not a rule.</p>



<p class="wp-block-paragraph">The modern check matters. Newer Core tests the whole mempool&#8217;s <strong>feerate diagram</strong>: the replaced transaction and its descendants together may not exceed a count (the old ceiling was <strong>100</strong>), and the replacement must <strong>strictly improve</strong> that diagram. With no unconfirmed relatives, this collapses into: <strong>pay absolutely more, at a higher fee rate.</strong> Note what the rule is: <strong>it is the mathematical expression of miner incentive compatibility, not a product promise to users.</strong> It exists so a miner who accepts the replacement is never worse off.</p>



<p class="wp-block-paragraph">RBF has an owner: <strong>only whoever holds the private keys for the original inputs can replace — usually the sender.</strong></p>



<p class="wp-block-paragraph"><strong>CPFP (child-pays-for-parent)</strong> is the other card, and it belongs to somebody else. Spend one output of the stuck transaction with a high fee; a child cannot confirm before its parent, so a miner who wants the child must take the parent, and the pair scores as combined fee over combined size. The interesting part is ownership: <strong>anyone holding one of the outputs can do this, and that is usually the receiver.</strong></p>



<p class="wp-block-paragraph">Two costs. The child carries the parent&#8217;s size in the average, so this is a rescue, not a bargain. And the parent must already sit in the miner&#8217;s pool — hence <strong>package relay</strong>: since Core 28.0 a parent and child can be relayed together opportunistically, and 31.0 widened that beyond the transaction types it originally covered.</p>



<p class="wp-block-paragraph"><strong>No mechanism can cancel a transaction that has been broadcast.</strong> A conflicting replacement is a competition, not a deletion. If some miner holds your original and finds a block first, the original confirms and your cancellation arrives too late. The button labelled Cancel is a replacement paying the coins back to you, and it is racing.</p>



<div class="k5acc">
<div class="k5-acc"><details class="k5-item"><summary>Can I cancel a transaction I already broadcast?</summary><p>No. Nothing can delete a broadcast transaction. A conflict is a race, and if a miner holding the original finds a block first, the original confirms.</p></details><details class="k5-item"><summary>Will a higher fee guarantee faster confirmation?</summary><p>No. It buys a good position on each miner&#8217;s private list, not a place in a queue. Nobody owes you inclusion, and losing is not refunded.</p></details><details class="k5-item"><summary>What does the Cancel button in my wallet actually do?</summary><p>It broadcasts a replacement that pays your coins back to yourself. The original stays valid and can still be mined by anyone holding it.</p></details><details class="k5-item"><summary>I am the receiver and my payment is stuck — can I fix it?</summary><p>Often yes, and you may be the only one who can. Whoever holds one of its outputs can spend it at a high fee, and a miner wanting the child must take the parent.</p></details><details class="k5-item"><summary>Do all nodes agree on which transactions are waiting?</summary><p>No. Each node keeps its own list with thresholds its operator chose, and two lists can stay different indefinitely without anything breaking.</p></details></div>
</div>



<h2 class="wp-block-heading" id="what-actually-happens">What Actually Happens</h2>



<figure class="wp-block-table"><table><thead><tr><th>The thing people say</th><th>What actually happens</th></tr></thead><tbody><tr><td>&#8220;My transaction is in the mempool.&#8221;</td><td>It is in the mempools of the nodes that chose to accept and relay it. No global list exists.</td></tr><tr><td>&#8220;A higher fee buys a place in line.&#8221;</td><td>It buys a better rank in each miner&#8217;s independent sort. Nobody owes you inclusion, and losing is not refunded.</td></tr><tr><td>&#8220;Consensus decides if my transaction is valid.&#8221;</td><td>A correct transaction can still be refused by node policy; that dies once a block includes it.</td></tr><tr><td>&#8220;The mempool is a queue.&#8221;</td><td>It is one candidate list per node, each with its own cap and its own fee floor.</td></tr><tr><td>&#8220;I can cancel a transaction I broadcast.&#8221;</td><td>There is no cancel. A replacement is a race the original can win.</td></tr><tr><td>&#8220;The estimator quotes the price of block space.&#8221;</td><td>It quotes what worked before; saved estimates expire after 60 hours.</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">What I would actually do with all of this:</p>



<ul class="wp-block-list">
<li><strong>Stop thinking in queues</strong> — think &#8220;which lists am I on, and who is sorting them today.&#8221;</li>


<li><strong>If you are the sender, RBF is your only card</strong>, so use it before you need it.</li>


<li><strong>If you are the receiver, CPFP is your card</strong>, and you may be the only one who can play it.</li>


<li><strong>Treat every fee estimate as a distribution</strong>, not a delivery date. A one-block target is a rounded probability.</li>


<li><strong>Assume the original can win the race.</strong> If a payment must not confirm in two forms, don&#8217;t send the second.</li>


<li><strong>Remember expiry is absolute.</strong> At 336 hours the fee rate stops mattering; if you still care, rebroadcast.</li>

</ul>



<p class="wp-block-paragraph">I am not going to quote you a live pool size or fee rate; both would be stale before you finished this sentence. The structure above is the part that does not go stale.</p>



<p class="wp-block-paragraph">(The End)</p>
]]></content:encoded>
					
					<wfw:commentRss>https://www.newsbbvn.com/crypto/bitcoin/945.html/feed</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Every 2,016 Blocks, Bitcoin Admits It Was Wrong: How the Difficulty Adjustment Works</title>
		<link>https://www.newsbbvn.com/crypto/bitcoin/934.html</link>
					<comments>https://www.newsbbvn.com/crypto/bitcoin/934.html#respond</comments>
		
		<dc:creator><![CDATA[BBVN Research]]></dc:creator>
		<pubDate>Sun, 18 Oct 2026 11:53:46 +0000</pubDate>
				<category><![CDATA[Bitcoin]]></category>
		<category><![CDATA[bitcoin]]></category>
		<category><![CDATA[Mining]]></category>
		<guid isPermaLink="false">https://www.newsbbvn.com/markets/934.html</guid>

					<description><![CDATA[Bitcoin retargets once every 2,016 blocks, clamps the move to 4x in either direction, and still carries a 0.05% off-by-one bias from its earliest releases. It is a thermostat that reads the thermometer once every two weeks, and it protects the issuance schedule rather than your confirmation time.]]></description>
										<content:encoded><![CDATA[
<div class="k4gauge">
<p class="k4-eyebrow">ONE EPOCH, 2,016 BLOCKS, AND THE WINDOW IN WHICH NOTHING CAN BE CORRECTED</p>
<div class="k4-bar"><span class="k4-fill"></span></div>
<div class="k4-scale"><span>5,040 min</span><span>20,160 min</span><span>80,640 min</span></div>
<p class="k4-dek">Bitcoin&#8217;s difficulty adjustment runs once every 2,016 blocks — call it fourteen days — and is deaf and blind in between. That single number explains nearly every complaint people have about confirmation times: the network is not steering toward ten-minute blocks, it is correcting its previous guess about how much hashpower exists, two weeks after the fact.</p>
</div>



<h2 class="wp-block-heading" id="0-2-016-4-032-the-only-heights-that-change-anything">0, 2,016, 4,032 — The Only Heights That Change Anything</h2>



<p class="wp-block-paragraph">A synced node sits at some height. Say 839,000. Consensus does not care about that number, except in one respect: it is not divisible by 2,016. Now take 838,656 (2,016 × 416) and 840,672 (2,016 × 417). Those two heights are different in kind. At each of them the node stops, looks backward across the epoch that just closed, and recomputes the target that every miner on earth will grind against for the next 2,016 blocks.</p>



<p class="wp-block-paragraph">Between two boundaries the target is frozen. A farm energising a new building and a farm going dark in the same hour are, to consensus, the same event: nothing at all. The network learns about both of them at the boundary, collapsed into one number, and not one second earlier.</p>



<p class="wp-block-paragraph"><strong>Difficulty adjustment is not a continuous controller with occasional checkpoints. It <em>is</em> a checkpoint.</strong> Everything people repeat about it — &#8220;Bitcoin targets ten minutes&#8221;, &#8220;Bitcoin adapts to hashrate&#8221; — describes the average behaviour of that checkpoint, not a promise the protocol makes to you at any given moment.</p>



<p class="wp-block-paragraph">So if your transaction is broadcast at height 839,000, one block after a large hashrate exodus, then for the next 1,672 blocks the network still does not know. It mines the old target. You wait. That is not a failure state; that is the design operating exactly as written.</p>



<h2 class="wp-block-heading" id="a-thermostat-that-reads-the-thermometer-once-every-fourteen-">A Thermostat That Reads the Thermometer Once Every Fourteen Days</h2>



<p class="wp-block-paragraph">Strip the mysticism away and difficulty adjustment is a negative feedback controller, the same shape as a thermostat: measure the output, compare it to a setpoint, correct the input. A thermostat does this several times a second, which is why it works.</p>



<p class="wp-block-paragraph">Bitcoin&#8217;s thermostat is the same machine with the sampling interval stretched to 1,209,600 seconds. It reads the thermometer, decides, sleeps for a fortnight, and wakes up to whatever it finds. Between two readings the room can freeze solid or catch fire; the controller does not know and cannot act. Nothing in the design says the room has to stay comfortable in the meantime.</p>



<p class="wp-block-paragraph">That is not an oversight, it is the trade. 2,016 × 10 minutes is exactly two weeks, and two weeks was chosen on purpose: short enough that the network tracks real hashrate trends, long enough that a lucky or unlucky run of blocks does not yank the target around. Block arrivals are a Poisson lottery and at small sample sizes variance dominates signal — <a href="https://www.newsbbvn.com/crypto/bitcoin/340.html">How Bitcoin Mining Works</a> covers the underlying lottery; the point here is only that the lottery&#8217;s <em>variance</em> is the noise this controller is deliberately built not to chase.</p>



<p class="wp-block-paragraph"><strong>A controller with a fourteen-day sampling interval is not a fast controller turned down. It is a categorically different object, and you should expect it to behave like one.</strong> The thermostat does not keep the house at 21 °C; it keeps the house near 21 °C on a fortnightly average. That is a far weaker promise than most people believe they were given.</p>



<h2 class="wp-block-heading" id="it-is-a-payroll-metronome-not-a-clock">It Is a Payroll Metronome, Not a Clock</h2>



<p class="wp-block-paragraph">Here is the inversion that shows up in almost every explanation, including the ones I repeated for years before thinking about it properly.</p>



<p class="wp-block-paragraph">Difficulty adjustment is usually introduced as the mechanism that &#8220;keeps blocks coming every ten minutes&#8221;. <strong>That is not what it protects. It protects the payout tempo — the rate at which block subsidies leave the coinbase and enter circulation.</strong> Ten minutes is the gear ratio that produces an acceptable tempo. It is not the quantity under control.</p>



<p class="wp-block-paragraph">Block interval is an output, not a setpoint. When hashrate falls and blocks take twenty minutes for a week, the mechanism has not malfunctioned; the <em>issuance</em> ran late, and that is the specific thing the correction exists to repair. The user waiting forty minutes for a confirmation is not a party the mechanism ever made a promise to — which is uncomfortable, and also true. <a href="https://www.newsbbvn.com/crypto/bitcoin/781.html">Bitcoin Halving Explained</a> is the place to look for why the emission cadence carries monetary meaning while your wait time does not.</p>



<p class="wp-block-paragraph">Call it what it is: <strong>a payroll metronome, not a clock.</strong> A metronome that notices, two weeks late, that the tempo drifted, and then nudges the weight on the pendulum.</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1280" height="950" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/diff4-2.jpg" alt="Three hourglasses of different sizes" class="wp-image-928"/><figcaption class="wp-element-caption">Wellcome Collection, CC BY 4.0, via Wikimedia Commons</figcaption></figure>



<h2 class="wp-block-heading" id="the-formula-and-why-it-is-almost-boring">The Formula, and Why It Is Almost Boring</h2>



<p class="wp-block-paragraph">One line does all the work:</p>



<p class="wp-block-paragraph"><code>new_target = old_target × (actual_timespan / expected_timespan)</code></p>



<p class="wp-block-paragraph"><code>expected_timespan</code> is a constant: 1,209,600 seconds. Not measured, not smoothed, not estimated — just two weeks written down. <code>actual_timespan</code> is measured the crudest way available: take the timestamp of the last block in the epoch, subtract the timestamp of the first block in the epoch, done. One subtraction. Every megawatt that arrived and every megawatt that left during those two weeks is compressed into that single difference.</p>



<p class="wp-block-paragraph">Slow epoch → actual larger than expected → target multiplied up → difficulty falls. Fast epoch → target multiplied down → difficulty rises. That is the entire controller. There is no feed-forward term, no derivative term, no memory of anything except the previous target.</p>



<div class="k4steps">
<ol class="k4-steps"><li><span class="k4-step-n">Block 1</span><div class="k4-step-b">The boundary block lands, its timestamp becomes the epoch&#8217;s reference zero, and the previous target is inherited unchanged.</div></li><li><span class="k4-step-n">Blocks 2–2,015</span><div class="k4-step-b">Miners grind against a frozen target; hashrate may double or collapse without consensus noticing anything.</div></li><li><span class="k4-step-n">Block 2,015</span><div class="k4-step-b">The node walks back DifficultyAdjustmentInterval() − 1 blocks to locate the first block, spanning 2,015 intervals rather than 2,016.</div></li><li><span class="k4-step-n">Block 2,016</span><div class="k4-step-b">Last timestamp minus first timestamp yields the actual timespan, the single number the whole correction is computed from.</div></li><li><span class="k4-step-n">Clamp</span><div class="k4-step-b">The timespan is forced into the 5,040–80,640 minute window, so no epoch can move difficulty more than 4× up or 75% down.</div></li><li><span class="k4-step-n">Multiply</span><div class="k4-step-b">old_target × (clamped_actual / 1,209,600) produces the target for the next 2,016 blocks.</div></li><li><span class="k4-step-n">Next epoch</span><div class="k4-step-b">The correction always lands one epoch late: it repairs the previous guess, never the present moment.</div></li><li><span class="k4-step-n">Steady state</span><div class="k4-step-b">Repeat forever; the block interval hovers near ten minutes only because the controller keeps over- and under-shooting.</div></li></ol>
</div>



<pre class="wp-block-code"><code>// Bitcoin Core, pow.cpp — CalculateNextWorkRequired(), condensed
unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast,
                                      int64_t nFirstBlockTime,
                                      const Consensus::Params& params)
{
    // off-by-one: we walk back (interval - 1), i.e. 2,015 gaps, not 2,016
    int nHeightFirst = pindexLast->nHeight - (params.DifficultyAdjustmentInterval() - 1);
    const CBlockIndex* pindexFirst = pindexLast->GetAncestor(nHeightFirst);
    int64_t nActualTimespan = pindexLast->GetBlockTime() - pindexFirst->GetBlockTime();
    const int64_t nExpected = params.nPowTargetTimespan;      // 1,209,600 s
    // clamp: [expected / 4, expected * 4]
    if (nActualTimespan < nExpected / 4) nActualTimespan = nExpected / 4;
    if (nActualTimespan > nExpected * 4) nActualTimespan = nExpected * 4;
    arith_uint256 bnNew;
    bnNew.SetCompact(pindexLast->nBits);
    bnNew *= nActualTimespan;
    bnNew /= nExpected;
    // never easier than the protocol ceiling
    if (bnNew > UintToArith256(params.powLimit))
        bnNew = UintToArith256(params.powLimit);
    return bnNew.GetCompact();
}</code></pre>



<p class="wp-block-paragraph">The clamp is the piece that makes the whole arrangement survivable:</p>



<figure class="wp-block-table"><table><thead><tr><th>What the epoch actually took</th><th>What the formula is fed</th><th>Largest possible move</th></tr></thead><tbody><tr><td>Under 5,040 minutes</td><td>5,040 minutes</td><td>Difficulty ×4</td></tr><tr><td>Between 5,040 and 80,640 minutes</td><td>The measured value</td><td>Strictly proportional</td></tr><tr><td>Over 80,640 minutes</td><td>80,640 minutes</td><td>Difficulty ×0.25 (a 75% cut)</td></tr></tbody></table></figure>



<p class="wp-block-paragraph"><strong>Even if 90% of the network&#8217;s hashrate vanished overnight, a single epoch could only give back 75%.</strong> The shortfall does not disappear — it rolls into the next epoch, and the next, which is precisely what &#8220;blocks stay slow for a while&#8221; means mechanically. The clamp is a speed limit on the correction itself, and it exists so that one pathological epoch cannot be exploited to mint blocks at trivial cost. In ordinary conditions the limit is never touched: single adjustments rarely exceed 10–15%.</p>



<h2 class="wp-block-heading" id="the-off-by-one-that-shipped-in-the-first-version-and-never-l">The Off-by-One That Shipped in the First Version and Never Left</h2>



<p class="wp-block-paragraph">Look at the second line of that function again. The code walks back <code>DifficultyAdjustmentInterval() − 1</code> blocks to find the first block of the epoch. But 2,016 blocks bound <strong>2,015</strong> intervals, not 2,016 — the gaps between fence posts are one fewer than the posts.</p>



<p class="wp-block-paragraph">So the measured timespan covers 2,015 gaps while the expected timespan still assumes 1,209,600 seconds, i.e. 2,016 gaps of ten minutes. The controller is quietly comparing apples to apples-minus-one, and the result is a systematic bias of roughly <strong>0.05%</strong>: the true long-run average block interval is about <strong>10.005 minutes</strong>, not 10.000.</p>



<p class="wp-block-paragraph">Is it worth fixing? No, and the reason is instructive. Fixing it changes consensus rules, which means a hard fork — every node on the network has to agree to switch on the same block or the chain splits. If you want to see what that coordination actually looks like in practice, <a href="https://www.newsbbvn.com/crypto/bitcoin/919.html">Soft Fork vs Hard Fork</a> walks through two real ones. A 0.05% timing bias is nowhere near the threshold where that risk is worth taking. So a bug found in the earliest code is still in the code, and will probably still be there in twenty years.</p>



<p class="wp-block-paragraph"><strong>That is what a mature protocol looks like from the inside: not a clean system, but a system where every remaining wart has been priced and left alone.</strong> It also tells you something about how much precision the designers thought the block interval deserved — approximately none.</p>



<h2 class="wp-block-heading" id="the-only-input-is-time-so-time-is-what-gets-guarded">The Only Input Is Time, So Time Is What Gets Guarded</h2>



<p class="wp-block-paragraph">Since the entire correction derives from one subtraction of two timestamps, timestamps are the attack surface. Miners fill them in. So the rules constrain them:</p>



<ul class="wp-block-list">
<li>A block&#8217;s timestamp must be <strong>greater than the median time of the previous 11 blocks</strong> (median-time-past). You cannot drag the chain&#8217;s clock backward.</li>


<li>A block&#8217;s timestamp may not be <strong>more than 2 hours ahead of the receiving node&#8217;s own clock</strong>. You cannot shove it far forward either.</li>

</ul>



<p class="wp-block-paragraph">Within that window a miner still has room to lie, and miners have occasionally lied. The point is that the room is bounded, and bounded on both sides: pushing timestamps forward to fake a slow epoch and harvest a difficulty cut is limited to what the 11-block median and the 2-hour ceiling allow. The guardrails are not elegant. They are just narrow enough that cheating does not pay.</p>



<p class="wp-block-paragraph">Note what this implies about the thermostat. Its only sensor is a pair of clock readings supplied by the parties being regulated. Everything downstream inherits that.</p>



<h2 class="wp-block-heading" id="there-is-no-emergency-brake">There Is No Emergency Brake</h2>



<p class="wp-block-paragraph">Bitcoin has no emergency difficulty adjustment. There is no clause anywhere in consensus that says &#8220;if blocks have been slow for N hours, do something now&#8221;. The 2,016-block boundary is the only place the target ever moves.</p>



<p class="wp-block-paragraph">Write out what that means when hashrate leaves abruptly:</p>



<ul class="wp-block-list">
<li>Hashrate disappears.</li>

</ul>



<ul class="wp-block-list">
<li>Blocks get slower immediately — that day, not in fourteen days.</li>

</ul>



<ul class="wp-block-list">
<li>The controller stays silent. It has no channel through which to learn.</li>

</ul>



<ul class="wp-block-list">
<li>At the boundary it cuts difficulty by at most 75%, no matter how much hashrate actually left.</li>

</ul>



<ul class="wp-block-list">
<li>If the exodus was larger than 75%, the target is still harder than the surviving hashrate can meet, and the deficit rolls into another slow epoch.</li>

</ul>



<ul class="wp-block-list">
<li>Users pay in confirmation latency; miners pay in revenue per unit of hardware. Both absorb it, by design.</li>

</ul>



<div class="wp-block-getwid-icon-box has-text-left has-background" style="background-color:#fbfcfd;padding:18px;border-radius:10px">
<div class="wp-block-getwid-icon-box__icon-container is-position-top"><div class="wp-block-getwid-icon-box__icon-wrapper" style="font-size:24px"><i class="fas fa-thermometer-half" aria-hidden="true"></i></div></div>
<div class="wp-block-getwid-icon-box__content">
<h4 class="wp-block-heading">It reads late</h4>
<p>The controller&#8217;s only input is one timestamp difference, and it takes that reading once per epoch — not per block, not per hour, not per day.</p>
</div>
</div>



<div class="wp-block-getwid-icon-box has-text-left has-background" style="background-color:#fbfcfd;padding:18px;border-radius:10px">
<div class="wp-block-getwid-icon-box__icon-container is-position-top"><div class="wp-block-getwid-icon-box__icon-wrapper" style="font-size:24px"><i class="fas fa-gauge-high" aria-hidden="true"></i></div></div>
<div class="wp-block-getwid-icon-box__content">
<h4 class="wp-block-heading">It moves slowly</h4>
<p>The clamp caps every correction at 4× up or 75% down, so even a 90% hashrate collapse takes several epochs to absorb.</p>
</div>
</div>



<div class="wp-block-getwid-icon-box has-text-left has-background" style="background-color:#fbfcfd;padding:18px;border-radius:10px">
<div class="wp-block-getwid-icon-box__icon-container is-position-top"><div class="wp-block-getwid-icon-box__icon-wrapper" style="font-size:24px"><i class="fas fa-hourglass-half" aria-hidden="true"></i></div></div>
<div class="wp-block-getwid-icon-box__content">
<h4 class="wp-block-heading">It promises nothing</h4>
<p>Slow blocks are not a defect the mechanism owes you a fix for; the lag between two boundaries is carried by miners and users.</p>
</div>
</div>



<p class="wp-block-paragraph">The largest single downward adjustment on record is the <strong>roughly 28% cut in July 2021</strong>, after China&#8217;s mining crackdown — an episode estimated to have taken somewhere between <strong>50% and 75%</strong> of global hashrate offline more or less at once. Both of those are approximations and should be read as approximations. What matters is the shape: the biggest shock in Bitcoin&#8217;s history produced a correction well inside the clamp, and it still took more than one epoch for block times to look normal again.</p>



<h2 class="wp-block-heading" id="the-control-group-bitcoin-cash-tried-the-fast-version">The Control Group: Bitcoin Cash Tried the Fast Version</h2>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1280" height="927" src="https://www.newsbbvn.com/wp-content/uploads/2026/10/diff4-3.jpg" alt="An engineering drawing of a worm gear and a spur gearwheel" class="wp-image-929"/><figcaption class="wp-element-caption">Wellcome Collection, CC BY 4.0, via Wikimedia Commons</figcaption></figure>



<p class="wp-block-paragraph">This is where the design argument gets real, because someone ran the experiment.</p>



<p class="wp-block-paragraph">When Bitcoin Cash split off on <strong>1 August 2017</strong>, it shipped an extra rule alongside the ordinary 2016-block adjustment: an Emergency Difficulty Adjustment. If the median time gap across the <strong>last 6 blocks</strong> exceeded <strong>12 hours</strong>, difficulty dropped by 20% immediately — target multiplied by 0.8 — and it could trigger on consecutive blocks, compounding.</p>



<pre class="wp-block-code"><code># Bitcoin Cash EDA, 2017-08-01 to 2017-11-13 (simplified)
EDA_HEIGHT     = 478559               # first BCH block
MEDIAN_BLOCKS  = 6
SLOW_LIMIT     = 12 * 60 * 60         # 12 hours
RELEASE_FACTOR = 4 / 5                # difficulty *= 0.8
def next_work_required(chain):
    tip    = chain.tip()
    target = bits_to_target(tip.bits)
    if tip.height >= EDA_HEIGHT:
        gaps   = [b.time - b.prev.time for b in last_n(tip, MEDIAN_BLOCKS)]
        spread = median(gaps)
        if spread > SLOW_LIMIT:
            # emergency release: make it 20% easier, right now
            return target_to_bits(min(target / RELEASE_FACTOR, POW_LIMIT))
    # the original 2016-block DAA keeps running underneath
    if (tip.height + 1) % 2016 == 0:
        return classic_2016_adjustment(chain)
    return tip.bits                    # unchanged</code></pre>



<p class="wp-block-paragraph">What happened next was not a bug. It was a control loop with two controllers fighting, and it oscillated:</p>



<ul class="wp-block-list">
<li>BCH price falls, miners leave, blocks slow down.</li>


<li>EDA fires, difficulty drops 20% per trigger.</li>


<li>BCH becomes more profitable per hash than BTC, so hashrate floods back in.</li>


<li>Blocks come extremely fast, difficulty climbs back up via the 2016-block rule.</li>


<li>BCH becomes unprofitable again, miners return to BTC, blocks slow down.</li>


<li>Repeat.</li>

</ul>



<p class="wp-block-paragraph">At its worst BCH ran thousands of blocks ahead of BTC, and by the time the EDA was retired more than <strong>100,000 BCH</strong> had been emitted earlier than the intended schedule. The payroll metronome was being cranked by hand, in both directions, and the tempo it was supposed to hold is exactly what got damaged.</p>



<p class="wp-block-paragraph">On <strong>13 November 2017</strong> a hard fork removed the EDA and replaced it with a new DAA that adjusts <strong>every block</strong>, using a moving window of the <strong>last 144 blocks</strong> toward a <strong>600-second</strong> target.</p>



<figure class="wp-block-table"><table><thead><tr><th></th><th>Bitcoin DAA</th><th>BCH EDA (Aug–Nov 2017)</th><th>BCH DAA (from 13 Nov 2017)</th></tr></thead><tbody><tr><td>Adjusts when</td><td>Every 2,016 blocks</td><td>Any block whose last-6 median gap exceeds 12 h</td><td>Every block</td></tr><tr><td>Looks at</td><td>First-vs-last timestamp of the epoch</td><td>Median gap of the last 6 blocks</td><td>Last 144 blocks</td></tr><tr><td>Nominal target</td><td>1,209,600 s per epoch</td><td>600 s per block</td><td>600 s per block</td></tr><tr><td>Under a hashrate shock</td><td>Blocks stay slow until the boundary; one epoch gives back at most 75%</td><td>Drops 20% per triggering block, compounding, until blocks speed up</td><td>Re-targets continuously from the 144-block window</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">Read that table as a trade, not a scoreboard. The EDA did what it was designed to do: it stopped blocks from being slow. What it could not do was stop <em>itself</em> from being profitable to game, because a controller that reacts to six blocks of data will chase anything, including its own previous reaction.</p>



<h2 class="wp-block-heading" id="why-bitcoin-keeps-the-slow-one">Why Bitcoin Keeps the Slow One</h2>



<p class="wp-block-paragraph">Put the two analogies back together, because they are the same object seen from two sides.</p>



<p class="wp-block-paragraph">The thermostat with a fourteen-day sampling interval is what the difficulty adjustment <em>is</em> mechanically: a feedback loop with an absurd delay, protected against its own delay by a clamp, and by a rule that limits how far the sensor itself can be lied to. The payroll metronome is what it <em>is for</em>: not your confirmation time, but the tempo at which new coins are issued, a tempo that matters precisely because nobody can vote to change it.</p>



<p class="wp-block-paragraph">Bitcoin chose the slow controller on purpose. A difficulty rule that reacts to six blocks is a difficulty rule that reacts to <em>miners who have noticed the rule</em>, and miners are the fastest learners in any system that pays them. Two weeks of enforced deafness is not sluggishness — it is the part of the design that makes the controller hard to game, because nobody can move enough hashrate for two weeks cheaply enough to make the exploit worth more than just mining honestly.</p>



<p class="wp-block-paragraph">That is the trade, stated without flinching: <strong>you get a monetary metronome that cannot be cranked, and you pay for it with confirmation times that are nobody&#8217;s guarantee.</strong> The 2021 shock was absorbed over several epochs. The 2,015-interval arithmetic error has been sitting in the code since the beginning and will outlive us. Neither is a scandal; both are what a controller built to resist its own operators looks like from the outside.</p>



<p class="wp-block-paragraph">So the honest question is not &#8220;why is Bitcoin&#8217;s difficulty adjustment so slow&#8221;. The honest question is this: if you had a machine whose only job was to keep paying out on schedule, and every participant in the system had a financial reason to make it pay out faster — would you really give that machine a panic button, and hand the button to them?</p>



<p class="wp-block-paragraph">(The End)</p>
]]></content:encoded>
					
					<wfw:commentRss>https://www.newsbbvn.com/crypto/bitcoin/934.html/feed</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
	</channel>
</rss>
