From: Cory Fields <foss@coryfields.com>
To: Bitcoin Development Mailing List <bitcoindev@googlegroups.com>
Subject: Re: [bitcoindev] Quantum Landmines and Vulnerable Coin Auctions
Date: Fri, 20 Nov 2026 14:15:43 -0800 (PST) [thread overview]
Message-ID: <ffd99327-f633-4e2e-bc54-cc1389ffebccn@googlegroups.com> (raw)
In-Reply-To: <3Si-X9YGMmYLUCsKqrf8g84uAsg2xdkZMDpHXcLgqC1_KTnCw1J8kylgHw8PyGNjMkT4tpxSfKwnVNxX8QbnzuSzFDkdGGe96a7q_GTLnWg=@proton.me>
[-- Attachment #1.1: Type: text/plain, Size: 8641 bytes --]
Attempting to use the Google Groups web interface to respond inline,
hopefully this goes ok...
On Wednesday, November 18, 2026 at 7:30:51 PM UTC-5 conduition wrote:
It's a neat idea conceptually (your superposition joke elicited a hearty
chuckle!), but I fear your stated goal of "make it impossible to reason
about how many coins are quantum-safe" is contrary to one of the most
important metrics we need: a gauge for the progress of PQ migration.
Without that we are effectively guessing about the ratio of classical/PQ
coins when making future soft fork decisions, which seems like shaky
ground.
It's not a goal, it's an observation. Deliberately making it impossible to
reason about how many coins are quantum-safe (and how much of a threat a
quantum computer actually poses) is possible. I agree that would likely not
be a good thing. But it's worthy of being common knowledge.
A quantum attacker could simply neglect to attack outputs created after the
"landmine" soft fork was activated, and be certain that they'll never step
on one. If any new output could be a landmine, the attacker would just
focus on old outputs, e.g. satoshi era coins, and still have plenty of
profit.
To be clear, landmines are new utxos which contain hidden proofs of signing
ability for _other_ utxos. After a landmine soft fork and pre-qday (so,
say, 2 years from now), if I were Satoshi, I could create a landmine which
embeds a proof that I can spend the coinbase output from block 1. Then
post-qday, If a quantum attacker attempts to steal the ancient coins, I
reveal the proof in my recent landmine. In doing so, I take the coins and
the attacker's collateral for myself, 100btc total.
It's likely true that Satoshi's coins will/can never be spent, but not
100%. As of now, if Satoshi is still around and capable of spending their
coins, they have very good reason not to do so as it would change the
economic assumptions held by many users. So even if they could, they likely
wouldn't. But if they were to wait until after qday and activate a
landmine, they could decimate the threat of future quantum attacks. Much
like the tripwire idea, the existence of the threat, however unlikely,
means it can't be ignored.
Pre-qday, He creates a quantum-safe output of 50btc with a secret leaf, but
in this case it commits to a the vulnerable output, a bid amount of 40btc,
and a new pubkey. This unspent transaction represents a staked bid of 40btc
in the event that a particular vulnerable output is ever spent. In order to
keep bidding sane, the allowed depth of bid-leaves could be constrained.
Post-qday, a quantum attacker finds the private key associated with the
vulnerable 50btc unspent output and spends it, along with the required
50btc of their own as collateral, to an output which has the above spending
conditions and is worth 95btc. This represents a bid of 45btc.
Because no landmine exists, the initial timeout comes and goes. Now an
auction begins and continues until a second time-out. During this auction
period, Bob reveals his staked 50btc output with a 40btc bid, and uses it
to take 40btc of the attacker's collateral. The original stolen coins are
lost, the attacker loses some or all of their collateral, and the auction
continues. If nobody outbids him, Bob takes the 40btc as profit.
This is confusing.
How does the network distinguish an attacker from the real honest user? If
the honest user is trying to rescue their coins, why do they have to endure
this rigmarole in order to do it, rather than using a rescue protocol like
commit/reveal?
A landmine _is_ a rescue protocol. It just has an additional incentive
feature. Perhaps I should've separated the two ideas in my original mail.
Other rescue schemes could use the collateral/timelock trick as well.
I left this out of the original message for simplicity, but it'd be trivial
to add an exception to the collateral/timeout rules if a pre-qday ownership
proof (in this case, a landmine) is included as an input along with the
vulnerable coin spend. So you'd either have to attach a proof _or_
collateral in order to spend a pre-qday utxo. In the absence of a proof,
the clock starts for the original owner to grab the attacker's collateral.
The same protocol could be used for other pre-qday signing ability reveals
like bip32 seed knowledge, landmines aren't special here.
Why does bob have any right to the coins involved in this transaction? He
hasn't proven anything, other than the fact that he predicted someone would
spend a given UTXO.
This is exactly the kind of question I was trying to evoke with the auction
thought experiments! At this point, Bob, the quantum attacker, and the
original owner all have the same ability to spend the coin. So who should
succeed? Assuming there's no rescue transaction possible, as far as the
outside world is concerned, all three are equal.
PQ conversations thus far have essentially boiled this down to 2 choices:
freeze the coins (nobody gets the coins which can't be safely rescued), or
leave them vulnerable. When leaving them vulnerable, the attacker will
almost certainly take the coins with exposed pubkeys, as the original owner
would've moved them if they could've and were aware of the quantum risk.
I'm introducing a new possibility: when a pre-qday spend happens, there's a
time window in which coins can be rescued with a proof of pre-qday
knowledge. If that timeout expires, a fair auction begins. This has the
benefit of avoiding a unilateral coin freeze while also not rewarding the
attacker more than any other user. Potentially going further and punishing
them for trying, leading to a "the only winning move is not to play"
scenario for everyone involved. The tricky part then becomes defining the
rules for the auction.
Why would landmine rules apply to this old legacy UTXO at all, given that
it was created beyond a landmine soft fork was deployed?
Landmines could be planted on any legacy utxo any time after a landmine
soft-fork and before qday.
Why does Carol's 30 BTC bid win over Bob's 40 BTC bid? I'm not sure i see
the logic here.
There are many ways to conduct an auction, this is just an example. In this
case, it's a silent auction where the highest bidder wins. But because
you're bidding on Bitcoin with Bitcoin, given two users with the same
stake, the winner is the person who's willing to take the _least_ amount of
profit.
Could you clarify what you mean by "staking"? AFAICT nobody has any coins
timelocked or staked in any enforceable way (except apparently for the
legacy UTXO?)
In this scenario, Bob has created his "bid" pre-qday by creating a 50btc
output which contains a hidden leaf which contains a bid amount and
reference to a vulnerable output. Post-qday, only pre-qday bids are
considered. If Bob spends his 50btc in the meantime via a different leaf,
he loses his bid as well. So even though the coin was never timelocked, its
age when revealed as a bid proves he had skin in the game.
As another auction scenario, it could be that the winner is decided based
solely on bid age. In yet another, a new output type could be added that
could _only_ be spent as a quantum bid, effectively locking it up forever
otherwise. That demonstrates a much bigger ante... If someone is willing to
potentially burn 50 coins in order to take (say) 25btc of a Satoshi-era
utxo, on a bet that qday comes years later and a steal is attempted, I'd
say they deserve the win.
The bid/stake/auction possibilities are endless :)
Secondary concern: The collateralization requirement makes it possible to
create outputs you cannot spend without access to more bitcoins for
collateral. Tractable but very awkward UX.
Thanks for pointing this out. See above about the exception for post-qday
spends which reveal pre-qday ownership proofs in the same tx. Like other
rescue schemes, no collateral is needed in that case.
regards,
conduition
Thank you very much for the thoughtful response!
Cory
--
You received this message because you are subscribed to the Google Groups "Bitcoin Development Mailing List" group.
To unsubscribe from this group and stop receiving emails from it, send an email to bitcoindev+unsubscribe@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/bitcoindev/ffd99327-f633-4e2e-bc54-cc1389ffebccn%40googlegroups.com.
[-- Attachment #1.2: Type: text/html, Size: 10407 bytes --]
prev parent reply other threads:[~2026-11-21 21:55 UTC|newest]
Thread overview: 5+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-04 21:05 [bitcoindev] Quantum Landmines and Vulnerable Coin Auctions Cory Fields
2026-11-17 15:51 ` 'conduition' via Bitcoin Development Mailing List
2026-11-17 17:25 ` Cory Fields
2026-11-18 23:45 ` 'conduition' via Bitcoin Development Mailing List
2026-11-20 22:15 ` Cory Fields [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=ffd99327-f633-4e2e-bc54-cc1389ffebccn@googlegroups.com \
--to=foss@coryfields.com \
--cc=bitcoindev@googlegroups.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox