Bitcoin has no activated post-quantum protection as of November 17, 2026. The leading mitigation proposal, BIP-360 (Pay-to-Merkle-Root, or P2MR), is still a draft at specification version 0.12.1, and no P2MR outputs exist on mainnet. That leaves a practical question that any node operator can answer today: how many coins sit behind public keys that are already visible on-chain? A Python scanner and a UTXO snapshot from Bitcoin Core 32.1 let you measure Bitcoin quantum exposure in about 90 minutes, with no third-party service in the loop.

Reported measurements from November 15 and 16 disagree sharply. One independent full-UTXO analysis put a much smaller amount of BTC in outputs whose public keys were already visible on-chain. Another service reportedly counted 7,177,007 BTC at addresses with revealed public keys, using a snapshot at block 975,909. Both can be right, because they count different things. The BIP-360 status coverage explains the proposal. The project below shows you the measurement behind the headline numbers, so you can reproduce the smaller one yourself and understand why the larger one needs more data.

The scanner reads the raw snapshot that bitcoin-cli dumptxoutset writes, classifies every unspent output by script type, and reports Bitcoin quantum exposure at rest in coins, outputs, and share. It ships with a synthetic fixture generator, unit tests, a cross-check against the RPC output, and a report diff for tracking change over time.

Don't miss new tech stories on Google

Add Shattered once in the Google app and our stories show up in your news suggestions.

What a UTXO-Set Quantum Audit Measures

A quantum computer large enough to run Shor’s algorithm could derive a private key from an elliptic-curve public key. Bitcoin’s signatures rest on that curve math, the same family of problems covered in the ECC vs RSA comparison. Hash functions are a different story. A coin locked to a hash of a key does not reveal the key until someone spends it, so the key stays hidden behind the hash until that spend.

That split is the whole basis of the audit. The question for each unspent output is simple: does its locking script already contain a public key, or only a hash of one? Outputs that carry the key are exposed at rest. They sit in the UTXO set with their key in plain view, and nothing the owner does with a wallet changes that.

Current explanations separate two attack windows. A long-exposure attack targets keys that sit visible on-chain for months or years. A short-exposure attack targets the minutes between broadcasting a transaction and its confirmation, when the key becomes visible for the first time. P2MR is aimed at the first window only. According to BitGo’s quantum computing guide, the proposal does not add a post-quantum signature scheme, so treating it as full protection would be a mistake.

Which output types leak a key

The classification this project uses follows the exposure categories that current analyses describe: P2PK, bare multisig, and P2TR are exposed when created. P2PKH and P2WPKH become exposed after the first spend or an address reuse reveals the key. Some P2SH and P2WSH outputs become exposed when a revealed redeem script contains a public key and a signature-checking opcode.

What the UTXO set can and cannot tell you

A snapshot lists only unspent outputs. It shows the locking script, the value, and the creation height of each coin. It does not show whether a hashed address was used before, which is exactly the history that reveals a key. So the scanner produces a lower bound: exact for P2PK, bare multisig, and P2TR, and blind to reuse exposure on hashed outputs.

That limit is not a flaw to hide. It tells you why the two published figures sit so far apart. A scanner that looks only at locking scripts lands near the smaller number. A service that also walks spent inputs to find revealed keys on hashed addresses lands near the larger one. Bain & Company’s 2025 post-quantum cryptography survey found that “73% of IT security professionals expect post-quantum cryptography to become a material risk within five years.” The same survey reported that “Only 9% of technology leaders surveyed said their organizations have a roadmap for addressing post-quantum cryptography.” Measuring your own exposure is a small first step toward a roadmap.

Prerequisites: Versions, Disk, and Time

You need a machine that can run a full Bitcoin node, plus a modest Python environment. The scanner uses only the standard library, so there is nothing to install from PyPI. The table lists what the steps assume. Python 3.12.3 is the version the code and tests ran on for this project. The category hub for related cryptocurrency tutorials covers the node-side background if you have never run one.

Older Bitcoin Core lines are a different case. 31.2 and 30.4 are listed as other current releases, but a secondary correction says the 29.x branch has reached end of life, so 29.5 should not be treated as maintained. The 29.5 release note carries the details for that line. Use 32.1 here, because it is the newest release and the one the steps below name.

If you do not run a node, you can still do Steps 4 through 8 against the synthetic fixture and see the whole pipeline work. You only need the node for Steps 1 through 3 and the real-data run in Step 9.

Step 1: Install Bitcoin Core 32.1 and Verify the Download

Download the release from the project’s own binary directory, then check the hash and signature before you run anything. A tampered node binary would make every later number meaningless, so this step is worth the two extra minutes.

The checksum command should print bitcoin-32.1-x86_64-linux-gnu.tar.gz: OK. The gpg --verify command needs the release builders’ public keys in your keyring, and it reports “Good signature” lines for the keys it knows. If it reports only unknown keys, import the builder keys from the project’s guix attestations repository first, and do not skip the check.

The last command prints the daemon version. Expect a line that ends in v32.1.0. If it shows an older version, another copy of Bitcoin Core is earlier in your PATH, so run which -a bitcoind to find it.

Windows and macOS users follow the same logic with the installer or archive from the same release page. The only later requirement is that bitcoin-cli can reach your node.

Step 2: Sync the Node and Confirm It Sits at the Tip

The snapshot is only as current as your node. A node still in initial block download would dump a stale UTXO set, and the report would describe a chain state from days or weeks ago. Start the daemon and wait for it to catch up.

Run the second command until blocks equals headers, verificationprogress reads 1.0 (or very close), and initialblockdownload is false. A fresh sync takes a long time on modest hardware, so most readers will already have a synced node and can skip straight ahead.

Do not read the exact numbers in your output as part of the audit. What matters is the equality of the first two fields and the false flag. Write down the block height anyway, because Step 3 stamps the snapshot with the base block, and Step 9 checks that stamp.

One practical note on timing: the chain keeps growing while you work. The snapshot freezes one block, and everything after that, including the final report, describes that block and no other. That is why every report records its base block hash.

Step 3: Dump the UTXO Snapshot

The dumptxoutset RPC writes the full unspent output set to a file in a compact binary format. The node process writes the file, so the path must exist on the node’s machine and be writable by the user that runs bitcoind. Relative paths resolve against the data directory.

The -rpcclienttimeout=0 flag matters because the default client timeout can expire before the dump finishes. The latest argument asks for a snapshot of the current tip instead of a rollback to an older block. Argument details have changed between releases, so run bitcoin-cli help dumptxoutset on your node if the command rejects the form above.

The RPC returns a small JSON object when it finishes. The fields to look for are coins_written, base_hash, base_height, path, and txoutset_hash. The redirect above saves that object, and Step 9 uses it to cross-check the scanner’s own count against the node’s.

The command refuses to overwrite an existing file, which protects an earlier snapshot from an accidental rerun. Use a new filename for each run, or move the old file out of the way.

Step 4: Create the Project and Read the Snapshot Format

Create a project folder with the seven files the next steps fill in. Everything runs on the standard library, so no virtual environment is required, although one does no harm.

Before writing the reader, you need the layout of the file. The snapshot starts with a fixed 51-byte header and then lists coins grouped by the transaction that created them.

After the header comes a sequence of groups. Each group holds a 32-byte transaction id, a CompactSize count of coins, and then that many coins. Each coin holds a CompactSize output index, a VARINT code that packs the creation height and a coinbase flag as height * 2 + coinbase, a VARINT compressed amount, and a compressed script.

Two encodings trip people up. CompactSize is the familiar Bitcoin wire format with 1, 3, 5, or 9 bytes. VARINT is a different base-128 scheme used only for disk storage, where the most significant group comes first and each continuation adds one. Mixing them up is an easy bug to introduce, and it produces garbage values instead of an error.

The script compression has six special cases. A leading size value of 0 means a 20-byte P2PKH hash follows, 1 means a 20-byte P2SH hash, 2 and 3 mean a compressed public key (32 bytes of X coordinate, with the tag carrying the Y parity), and 4 and 5 mean an uncompressed public key stored in the same compact form. Any size of 6 or more means a raw script of size - 6 bytes.

Nothing in this format description comes from your own node yet. Step 8 proves that the reader and a writer built from the same description agree with each other, and Step 9 proves the reader agrees with a real snapshot. Both steps are necessary, because a round trip alone cannot catch a mistake that the writer and reader share.

Step 5: Write the Streaming Reader

The reader maps the file into memory with mmap and walks it with an integer position. That avoids reading multi-gigabyte files into Python objects and keeps memory flat. It yields one header object first and then one tuple per coin.

Three details deserve attention. The base block hash is reversed before hex-encoding, because Bitcoin stores hashes in one byte order and displays them in the other. The reader checks the magic bytes and raises an error on mismatch, so pointing it at the wrong file fails loudly. At the end, it compares the final position with the file length and raises on trailing bytes. A truncated file or an unexpected format revision almost always trips that check, which makes it your best early warning on real data.

The generator yields tuples instead of building a list. For a set with hundreds of millions of entries, a list would exhaust memory. The scanner consumes the stream one coin at a time and keeps only counters.

The amount decoder inverts Bitcoin Core’s compressed amount scheme, which factors out trailing decimal zeros. If you ever see absurd totals later, check this function first, then the VARINT reader.

Step 6: Classify Scripts by What an Attacker Sees

The classifier maps each coin to a category and a single boolean: is a public key visible while the coin is unspent? The mapping follows the table from the first section. Compressed scripts are classified by their tag. Raw scripts are classified by length and fixed bytes.

P2TR deserves a note. The scanner counts every Taproot output as exposed at rest, because the output key sits in the script. That is a conservative reading. Some Taproot outputs may disable the key path with an unspendable internal key, which removes the key-spend route even though the output key is still visible. You cannot tell those outputs apart from the locking script alone. A Bitcoin BIPs pull request on “Unspendable Internal Keys for Wallet Policies” (BIP-395) reportedly discusses exactly this kind of exposure classification, but it is a draft proposal and not something the scanner can use today.

P2MR is the proposed answer for new outputs. It removes the key-path spend and keeps the committed script tree instead of an internal key. It does not retroactively protect anything already in the UTXO set, and it does not replace the signatures themselves. The post-quantum signature candidates are a separate track from the output format, and a full migration would need both.

The classifier ignores a few real-world edge cases on purpose. It does not recognize pay-to-anchor outputs or other newer standard forms, so they land in other. Check the other share on real data. If it is large, extend classify with the new patterns before you trust the exposed percentage.

Step 7: Build the Scanner and the Report

The scanner streams every coin through the classifier and accumulates four things: counts and value per category, exposed value by halving epoch, exposed value by UTXO size bucket, and the largest exposed outputs. Halving epochs are blocks divided by 210,000, a fixed protocol interval, so they work as a rough age axis without any outside data.

The report keeps raw fields (counts, BTC, shares) and a few derived ones. It records the base block hash from the header, whether the scan was complete, the elapsed time, and an optional SHA-256 of the snapshot file. A partial scan from --limit is labeled as a partial sample in the console output and in the JSON, so nobody mistakes a sample for a full measurement.

The largest-exposed list uses a heap that never grows beyond the requested size. That keeps the memory cost constant, even when millions of outputs are exposed.

Shares use the total value of scanned outputs as the denominator. That choice matters when you compare against other published figures. Some measurements divide by circulating supply, and others divide by a UTXO-set total. Step 11 shows how much the denominator changes the headline percentage.

Step 8: Test the Project Against a Synthetic Snapshot

You cannot unit-test a parser against a snapshot you have not got yet, so build one. The fixture writer is the exact inverse of the reader: it encodes VARINTs, compresses amounts and scripts, groups coins by transaction id, and writes the 51-byte header. It draws category weights from a fixed mix, so the fixture shows you the pipeline working, and the percentages it produces are inventions.

Now the tests. They cover VARINT round trips and known byte strings, amount compression round trips, one classification per output type, and three end-to-end cases: a clean fixture parses completely, a file with trailing bytes raises, and a file with the wrong magic raises.

Now generate a 200,000-coin fixture and scan it. The fixture is deterministic for a given seed and Python version, and the steps here were run on Python 3.12.3.

Every number above comes from the synthetic fixture. The zero base block hash and the uniform value spread are artifacts of how the generator draws them, and none of it describes the real chain. The point of the run is that the 200,000 coins written equal the 200,000 coins parsed, and that the exposed flag lands only on the three at-rest categories.

Scan speed depends on your machine. Real snapshots will run slower than the synthetic fixture because of disk reads and less regular scripts, so measure your own run with --limit before committing an hour to it.

Step 9: Run the Scanner on Your Real Snapshot and Cross-Check the Totals

Point the scanner at the file from Step 3 and save the JSON report. Add --hash so the report carries the file’s SHA-256, which lets anyone confirm they analysed the same bytes. Hashing reads the whole file once more, so it adds time on a large snapshot.

The cross-check script compares the saved RPC output with the report. It fails if the coin count differs, if the base block hash differs, or if the scan was only a partial sample. This is the check that tests your reader against a real node. If the parse is wrong anywhere, the trailing-byte guard in the reader or the coin count here will catch it.

A passing run looks like this. The height in this example came from a hand-written test JSON, not from a real node, and the output is only there to show the format.

A failing run prints each problem on its own line and exits with status 1, which makes the script safe to chain in a scheduled job.

Do not publish or act on a number from a run that failed the cross-check. A mismatch means one of three things: the report and the RPC output come from different dumps, the file was truncated, or the format revision on your node differs from the layout in Step 4. The troubleshooting section covers each case.

Step 10: Read the Report Without Overstating It

Start with the categories table, which is the core of your Bitcoin quantum exposure result. The three exposed categories (P2PK, P2TR, bare multisig) add up to the exposed-at-rest total. Everything else is hidden behind a hash today. Then look at how the exposed value splits between them, because each one implies a different remedy.

P2PK outputs date from the earliest era of the chain, and the halving-epoch table will show them clustered in the low epochs. Those coins carry their keys in plain view, and the owners may not be reachable. P2TR value skews recent, since Taproot activated in November 2021, and its holders are active wallet users who could migrate if a new output type shipped. A report that shows most of the exposed value in P2TR describes a different problem from one that shows it in old P2PK, even when the totals match.

The size buckets show concentration. A handful of large outputs can account for much of the exposed value, and the largest-exposed list names them by height and category. That list helps you tell whether the exposure is a long tail of small coins or a few big ones.

A worked reading helps. In the synthetic fixture from Step 8, P2TR holds most of the BTC flagged as exposed at rest, while P2PK and bare multisig hold much smaller shares. The fixture draws creation heights uniformly, so its halving-epoch table comes out flat, which real data will not do. On a real snapshot, read the table the other way around: where it is lumpy, something happened on-chain in that era, and the era tells you who the likely holders are.

Also compare exposed value with exposed count. A category with many outputs and little value (dust-sized Taproot outputs, for instance) matters for wallet software and node resources, while a category with few outputs and large value matters for custodians and long-term holders. The report carries both numbers per category so you can tell the two stories apart.

Be careful with phrasing. “Exposed at rest” means the key is visible in the output. It does not mean anyone can steal the coins today, and a number from this scanner measures future risk, not a loss in progress. Anyone who wants to check their own addresses instead of the whole network can follow the wallet-level quantum exposure audit.

The JSON report holds the same data in machine-readable form. Keys like exposed_by_halving_epoch and exposed_by_utxo_size drop straight into a spreadsheet or a plotting script.

Step 11: Reconcile Your Number With Published Estimates

Now compare your Bitcoin quantum exposure result with the third-party figures from the opening. You will probably land near the smaller one, because your scanner and that analysis make the same cut: classify every locking script, and count P2PK, bare multisig, and P2TR as exposed. Reported figures from that kind of analysis, published on November 15 and 16, came in far below the larger estimates. Small differences are expected, and they come from different snapshot heights.

The larger numbers add a second ingredient. Glassnode was reported as estimating 7.12 million BTC, or 35.4% of issued supply, behind public keys already visible on-chain, per Brave New Coin’s summary. ChainQuery reported about 7.2 million BTC. Those estimates include hashed addresses whose keys were revealed by an earlier spend, so they need chain history that a UTXO snapshot does not contain.

Denominators also differ. One analysis divided by its UTXO-set total and got a low percentage. Others divide by issued or circulating supply, which gives percentages in the mid-30s for the larger estimates. Always compare the numerator and the denominator, not just the percentage. A separate, higher estimate, covered in the AI risk to Bitcoin coverage, shows how much room these definitions leave.

Finally, check the status of the fix. BIP-360 is a Draft, and no activation mechanism, signalling period, or activation date has been confirmed. A related draft, BIP-361 (Post Quantum Migration and Legacy Signature Sunset), reportedly remains a draft too, and the debate over migration timelines is still open. Strategy was reported on November 13 and 14 to have said Bitcoin could adopt quantum-resistant upgrades if and when needed, which was a general statement and not a technical proposal or schedule.

Step 12: Schedule the Scan and Track Drift

One snapshot is a photograph. A series of snapshots shows whether the exposed share grows or shrinks. The diff script compares two JSON reports and prints the change per category.

That output compares two synthetic fixtures built from seeds 7 and 8, so the changes are random noise. On real snapshots, the interesting movements are slow. P2TR share should rise as users adopt Taproot, and P2PK should barely move except when a long-dormant output is spent.

A weekly shell script ties Steps 3, 9, and 12 together. It dumps the snapshot, scans it, cross-checks the result, diffs against the previous report, and deletes the large snapshot file. The reports are small, so keep them forever.

Register it with cron, for example 0 3 * * 0 /srv/qscan/run_weekly.sh for a Sunday 03:00 run. The directory must be writable by the user that runs bitcoind, since the node writes the snapshot. Pipe the cron output to a log or a mail alias so a failed cross-check does not go unseen.

The Complete Project at a Glance

By this point the folder holds a full working tool. Seven Python files and one shell script cover the node handoff, the parse, the classification, the report, the verification, and the long-term tracking. The layout keeps each concern in its own file, so a change to one rarely touches another.

The run order for a one-off audit is short. Dump the snapshot, scan it, cross-check it, and archive the JSON report next to the RPC output. For a repeat audit, the weekly script does the same sequence and adds the diff. Nothing in the chain needs a network connection after the node has synced, which keeps the audit independent of any outside data provider.

The shell’s AND operator on the last line matters. The success message prints only when the cross-check exits cleanly, so a mismatched run never ends with a reassuring line.

Common Pitfalls

Most bad numbers from this kind of audit come from a handful of repeat mistakes. Check each one before you share a result.

  • Reporting at-rest exposure as total Bitcoin quantum exposure. The scanner cannot see reuse on hashed addresses. Say “lower bound” every time, and name the output types you counted.
  • Dumping from a node that is still syncing. The snapshot would describe an old block. Confirm that initialblockdownload is false before Step 3.
  • Mixing up VARINT and CompactSize. The two encodings look similar and fail silently. The reader uses VARINT for the height code, amount, and script size, and CompactSize only for counts and output indexes.
  • Forgetting to reverse the block hash. The stored byte order differs from the displayed one. If your base hash never matches the RPC’s base_hash, this is the usual cause.
  • Comparing percentages with different denominators. A share of UTXO value, a share of issued supply, and a share of circulating supply are three different numbers.
  • Treating every P2TR output as theft-ready. The output key is visible, but some outputs may have no usable key path. The scanner marks them exposed because the script alone cannot say otherwise.
  • Comparing runs from different base blocks without saying so. A day of chain activity moves the totals. Always print the base block hash next to the number.
  • Acting on the number before moving your own coins. A network-wide figure says nothing about your wallet. The quantum-proof wallet steps cover what an individual holder can do.

Troubleshooting

These are the problems most likely to show up, with a fix for each. Several of them point back to the format notes in Step 4.

Errors in the dump step

  • “path already exists” from dumptxoutset. The RPC will not overwrite files. Use a dated filename or move the old snapshot away.
  • The RPC call times out. Pass -rpcclienttimeout=0 so the client waits for the dump to finish.
  • Permission denied or no such directory. The node process writes the file, not your shell. Create the directory and give the node’s user write access, or use a path inside the data directory.
  • The latest argument is rejected. Argument forms differ between releases. Run bitcoin-cli help dumptxoutset and use the form it documents for your version.
  • The dump fails or looks stale while the node syncs. Wait for initial block download to finish, then dump again.

Errors in the scan step

  • “not a dumptxoutset snapshot (bad magic bytes)”. You passed the wrong file, or a download or copy truncated the start. Check the first bytes with xxd -l 16 utxo.dat. The first five bytes should read 75 74 78 6f ff.
  • “trailing bytes: parsed X of Y”. The reader stopped before the end of the file. Either the file format revision differs from Step 4 or your copy is damaged. Compare the version field and rerun the dump.
  • The cross-check reports a coin count mismatch. The RPC JSON and the report come from different snapshots. Rerun both from one dump and keep them together.
  • The “Other / non-standard” share is large. The classifier lacks a newer output type. Print a few unclassified scripts, then add patterns to classify.
  • The scan is much slower than the fixture rate. Disk reads can dominate on real data. Put the snapshot on fast local storage, and time a --limit 5000000 run first to project the total.
  • Your exposed share differs from a published figure. Compare the denominator and the exposure definition first, as in Step 11. Then compare snapshot heights.

Advanced Tips

Once the baseline works, a few extensions turn the project into a research tool.

Add history-aware exposure. To approach the larger published estimates, you need the keys revealed by earlier spends. That means walking blocks, extracting public keys from spending inputs, hashing them, and joining the result against hashed outputs in the UTXO set. It is a much heavier job than the snapshot scan, and it needs either a transaction index or a block-by-block pass. Plan for it as a separate project.

Take historical snapshots. Recent Bitcoin Core releases document a rollback mode for dumptxoutset that targets an earlier block. Check the help text on your node. A series of historical dumps would let you plot how the exposed share has evolved since Taproot activated in November 2021.

Model a P2MR migration. The size buckets and halving-epoch tables are a starting point for scenario analysis. If a new output type activated, how much exposed value sits in outputs that a regular wallet could move, and how much sits in dormant old coins? The report gives you the split by category and age.

Watch the proposals, not the headlines. BIP-360 changed four times during 2026 according to one summary, and the specification page lists version 0.12.1 dated July 24, 2026. A Bitcoin Core pull request for a post-quantum signature tool using ML-DSA-65 was also reportedly updated through November 16, which counts as development work and not as consensus activation. NIST’s guidance on retiring RSA and elliptic-curve signatures, covered in the IR 8547 transition summary, is a useful external clock.

Spot-check with an independent tool. Address-level checkers can confirm your classification logic on a few known outputs. BitGo reportedly offers a Bitcoin Quantum Resistance Score page that inspects addresses using public on-chain data, and an open-source project called p2mr-assurance-lab describes a conformance-testing kit for BIP-360. Neither is an official Bitcoin Core feature. Use them as second opinions, and never as a replacement for the cross-check against your own node.

Speed up the hot loop if you must. The per-coin work is small and mostly integer decoding. If a full pass is too slow for your hardware, profile it first, then try a faster interpreter or move only iter_coins to a compiled language and keep the reporting in Python.

Turning the Report Into Decisions

A measurement only pays off when somebody acts on it. The right action depends on who you are, and the report gives each audience a different slice.

Individual holders should treat the network figure as background and run a wallet-level check instead. The actions that hold up under every scenario are cheap: stop reusing addresses, keep wallet software current, and avoid parking large balances on outputs that expose a key. None of that depends on BIP-360 activating.

Custodians and exchanges carry the most concentrated exposure, and the largest-exposed list and the size buckets show whether a few big outputs sit in key-visible categories. An inventory of those outputs, repeated weekly with the diff script, gives a risk team a trend line instead of a one-off screenshot.

Wallet and protocol developers care about the category mix. A rising P2TR share means more users would need a migration path if a key-path-free output type activated. The mix also tells you how much value a migration could actually reach, and how much sits in old outputs whose owners may never move it.

Journalists and analysts should publish the method with the number. State the base block hash, the exposure definition, the denominator, and whether the scan was complete. A result that carries those four facts can be checked by anyone who runs their own node, which is the whole point of doing the audit locally.

Whatever the audience, keep the status of the fix in view. BIP-360 is a draft with no activation date, it reduces long-exposure risk only, and a post-quantum signature scheme remains a separate piece of work. Your report measures the problem. It does not shorten the timeline for solving it.

Frequently Asked Questions

What is Bitcoin quantum exposure? It is the amount of bitcoin held in outputs whose public keys are already visible on-chain. A UTXO snapshot measures the at-rest part of it, which covers P2PK, bare multisig, and P2TR outputs.

Is Bitcoin quantum-safe today? No. As of November 17, 2026, Bitcoin has no activated post-quantum protection. BIP-360 is a draft, no P2MR outputs exist on mainnet, and no post-quantum signature scheme is deployed.

Does BIP-360 make Bitcoin post-quantum? No. It changes the output structure by removing the Taproot key-path spend, which reduces long-exposure risk. It does not add a post-quantum signature algorithm and does not address short-exposure attacks during the transaction’s confirmation window.

Why does my scan show less exposure than Glassnode or ChainQuery? Your scan counts only outputs whose locking script contains a key. Those services also count hashed addresses whose keys were revealed by earlier spends, which a UTXO snapshot cannot show.

Do I need to run my own node? For real data, yes. The snapshot comes from your own node’s dumptxoutset RPC, so you do not trust anyone else’s numbers. You can run Steps 4 through 8 on the synthetic fixture without a node.

How long does the scan take? On the synthetic fixture, the scanner finished quickly. Real snapshots will be slower, so time a limited run on your own hardware first.

What should I do with my own coins right now? Nothing in the protocol requires action today, and current coverage describes BIP-360 as requiring no user action yet. Avoid address reuse, keep your software updated, and follow the proposals. The comparison of NIST’s post-quantum standards shows where signature standards stand outside Bitcoin.

Can I trust a number from a scan that skipped the cross-check? No. The cross-check is the test that ties your reader to a real node. Run it every time.

Marcus Bell covers applied security: authentication, TLS, phishing, and the everyday decisions that keep accounts and data safe. He focuses on turning advice people usually ignore into steps they will actually follow.