SHRINCS for Bitcoin: Quantum-Safe Signatures Explained12 min read2,400 words

SHRINCS for Bitcoin: Quantum-Safe Signatures Explained

Learn how SHRINCS could protect Bitcoin from quantum-era attacks, why stateful keys put wallets at risk, and what larger signatures could mean for fees.

SHRINCS Bitcoinpost-quantum Bitcoin signaturesBitcoin quantum securitystateful signaturesBitcoin transaction fees
SHRINCS for Bitcoin: Quantum-Safe Signatures Explained

Bitcoin's Quantum-Safe Signature Problem Is a Wallet Problem, Too

Bitcoin's long-term security isn't just about keeping the software patched. As computers get more powerful, the cryptography behind transaction signatures may need to change. One proposal now under review, SHRINCS, tries to stay on familiar ground: it's built around SHA-256, a hash function already used across Bitcoin, rather than betting everything on brand-new cryptographic assumptions.

That said, using a known hash function doesn't erase implementation risk. SHRINCS pairs a compact, stateful signature path with a larger stateless fallback. The compact route can help keep transactions smaller - but it only works if wallets track one-time signing keys correctly. Accidentally reusing key state could be disastrous. And if a wallet falls back too often, transaction sizes could bloat enough to matter for block space.

So SHRINCS is a useful test case in the broader "quantum-readiness" debate for Bitcoin. The key question isn't only whether the cryptography is sound. It's whether wallets can use it safely, whether the network can handle the added cost, and whether the ecosystem actually wants the trade-off. Here's what SHRINCS is aiming to do, where the risks show up, and what should be tested before anyone treats it as an adoption-ready option.

What problem is SHRINCS designed to solve?

Bitcoin uses digital signatures so people can prove they're authorized to spend specific coins. Today, signature systems such as ECDSA and Schnorr rely on elliptic-curve cryptography. In the long run, a sufficiently capable quantum computer could undermine some of those systems. That's a real concern - but it's not evidence that current Bitcoin signatures are breakable with today's machines. Still, replacing a core cryptographic building block isn't something the network can roll out overnight.

SHRINCS is a proposed hash-based signature scheme designed to support a path toward post-quantum security. Its security is tied to SHA-256, the hash function already central to Bitcoin's proof-of-work and other components. The approach is conservative in one way: it leans on a widely used primitive instead of introducing a completely unfamiliar foundation. But that doesn't mean the scheme is automatically safe or ready for deployment. The scheme itself, the way it's implemented, and the behavior required from wallets all need scrutiny.

Blockstream researchers have explored the proposal, including research director Jonas Nick and researcher Mikhail Kudinov, along with collaborators. A draft Bitcoin Improvement Proposal and a security analysis have been circulated for review. The working group's next step shouldn't be to tell the world to trust the idea - it should be to invite cryptographers, engineers, wallet developers, and protocol contributors to stress-test the design while it's still being refined.

That distinction matters. Bitcoin protocol changes have to work across a messy reality: different node implementations, wallets, custodians, exchanges, and everyday users. A scheme can look good in a paper and still be hard to operate safely at scale. For SHRINCS, the core question is whether the security assumptions hold up under ordinary wallet use: backups and restores, device failures, duplicated data, and user mistakes.

The practical goal isn't only "quantum resistance." It's a migration path that protects funds without making standard Bitcoin usage unsafe or impractically expensive. SHRINCS tries to spell out that tension: use compact signatures when wallet state can be managed reliably, and fall back to a larger option when it can't.

How do the stateful and stateless paths differ?

SHRINCS includes two spending paths. The stateful path uses one-time signing keys. Each piece of state is only safe for a single signature, so the wallet has to track which state has already been used. The upside is size. Depending on the version or configuration, stateful signatures are reported at roughly 548 to 4,619 bytes. They're still larger than today's Bitcoin signatures, but generally smaller than the stateless alternative.

The stateless path avoids relying on that same kind of tightly managed one-time state. Its signatures are reported at 5,777 bytes. That's a meaningful increase in data per signature, but it avoids the specific failure mode where a wallet reuses one-time state. In other words, it's not a free upgrade - it's there as a fallback for cases where the wallet can't be confident the stateful path is safe.

If you've worked with systems that depend on nonces, counters, or one-time credentials, the trade-off will feel familiar: adding state can improve efficiency, but it also turns every system that creates, stores, restores, or synchronizes that state into part of the security boundary. Stateless operation often sacrifices some efficiency to reduce the need for that coordination.

Compared with current Bitcoin signatures, the engineering challenge is clearer. ECDSA signatures are typically about 71 bytes, and Taproot Schnorr signatures are about 64 bytes. Even the smallest SHRINCS stateful signatures are substantially larger. The stateless signature is larger still. Those numbers don't prove the scheme is unworkable, but they do show why wallet behavior and network economics can't be treated separately.

There's also room for changes. The reported signature sizes (and the design details behind them) should be treated as proposal figures, not fixed constants. The researchers have mentioned ongoing optimization work, including research supported by AI-based methods. Any optimization has to be reviewed carefully - smaller outputs are useful only if the security properties stay intact.

Why is wallet behavior a security requirement?

The most important implementation risk in SHRINCS isn't some obscure cryptographic break. It's accidental reuse of one-time state. For the stateful path, if a signing key's state gets used more than once, the assumptions behind the scheme can fail. In the worst case, an attacker could forge a signature and steal funds tied to the affected address.

That puts wallets front and center. A wallet can't treat state tracking as a convenience detail or offload the responsibility onto users to remember what's safe. The implementation has to manage state reliably and avoid unsafe signing. Nick's warning is blunt: users shouldn't be able to trigger catastrophic failure through ordinary behavior.

And in practice, wallet designers have to plan for the ugly parts, not just the "happy path." What happens after restoring from an old backup? What if two independent copies of the wallet run at the same time? What if state is lost, duplicated, or corrupted? What if the wallet can't verify whether a counter has already been consumed? A robust design needs a defined response to those cases, not a vague "don't do that" message aimed at users.

The proposal's suggested safety rule is that wallets should automatically switch to the stateless fallback whenever the state counter could be compromised. That makes the fallback part of the design, not a hidden "advanced" toggle. It also creates a product-level obligation: the wallet should make the safe choice without requiring users to diagnose a cryptographic state problem.

This is where the specification has to be concrete. It should define when the stateful path is allowed, what counts as uncertain state, and what the wallet must do when uncertainty appears. Implementations should then be tested for backup recovery, device migration, concurrent wallet copies, and interrupted signing. Those aren't exotic edge cases; they're normal events in a wallet's life.

A simple way to evaluate SHRINCS: if safe operation depends on a user remembering an invisible technical constraint, then the design isn't ready for mainstream use. Automatic fallback helps, but it doesn't remove the need for careful implementation, review, and clear recovery behavior.

Could SHRINCS make Bitcoin transactions more expensive?

Yes - larger signatures can affect both transaction costs and how many transactions fit in a block. Bitcoin's fee market responds to competition for limited block space. When a transaction is bigger, it generally needs to pay more to get the same level of priority during busy periods. If post-quantum signatures end up several times larger than today's, the impact isn't only a wallet issue. It can reduce network capacity and affect who can realistically afford to transact.

The two SHRINCS paths create different versions of this trade-off. A stateful signature can be substantially smaller than a stateless one, but it requires reliable state management. A stateless signature removes that particular burden, but at 5,777 bytes it consumes more block space. If wallets only fall back to stateless signing when state is uncertain, the network might avoid paying the higher size cost on every transaction. If stateless use becomes common, the extra data could reduce the number of transactions that fit in a block.

That size difference is a warning, not a full forecast. Fees depend on adoption, how transactions are constructed, how block space demand evolves, and how the proposal changes over time. Signature size alone can't tell you what fees will look like. But it's still fair to ask whether the extra data shifts the value proposition for users already dealing with high fees or limited access during congested periods.

There's also a distribution question. Bigger transactions may be easier for large custodians to absorb than for someone making a small payment. If the cost of using a "more secure" signing path makes routine transactions harder to access, the ecosystem has to decide whether that's an acceptable security trade-off - and how to manage the transition.

The right response isn't to dismiss the idea because signatures are large, or to assume future optimizations will automatically erase the downside. Developers should model multiple scenarios: routine stateful usage, occasional fallback, and widespread stateless usage. Then they should examine transaction size, block inclusion, fee pressure, and wallet recovery behavior under each scenario.

The main point is system-level capacity. A signature scheme can improve one part of Bitcoin's security story while stressing another: affordable access to block space. That trade-off needs analysis before deployment, not after wallets and users are already committed to it.

What needs to happen before Bitcoin could adopt SHRINCS?

SHRINCS is an emerging proposal, not an adopted Bitcoin standard. A draft BIP and a published security analysis are a starting point for review, but the next step needs broad feedback from people who can test different parts of the system. That includes cryptographers assessing the scheme, protocol developers checking how it fits with Bitcoin, and wallet teams testing whether state can be handled safely in real products.

Review should cover the whole lifecycle, not just the signature algorithm. That means key creation, signing transactions, recording and restoring state, handling multiple wallet copies, and recovering from failed devices. It also needs testing of the automatic fallback rule: if a wallet can't establish that one-time state is unused, it should behave predictably and safely rather than continuing and hoping for the best.

Performance and cost need their own track, too. The signature sizes should be measured in realistic transaction contexts, then evaluated against different levels of network demand. If optimizations are introduced, reviewers should verify that any size reductions don't weaken the security analysis. The network also needs to consider how the proposal would affect existing users and infrastructure during migration.

That's why feedback matters before anyone treats SHRINCS like a ready-made solution. Bitcoin changes require coordination across stakeholders who don't share one roadmap or one decision-maker. Security researchers can find cryptographic problems, but they can't decide alone what fee impact is acceptable or how wallets should handle recovery. Those questions have to be debated across the ecosystem.

Researchers involved through groups including Brink and OpenSats help bring in more contributors - but help doesn't replace independent scrutiny. The proposal has to survive skeptical testing, implementation experiments, and feedback from the people who will actually pay the operational costs.

So the adoption bar should be cumulative: credible cryptographic analysis, an unambiguous specification, wallet implementations that make unsafe state reuse hard or impossible, and a clear account of block-space and fee consequences. If even one of those is missing, "post-quantum" isn't enough. Bitcoin needs something that works under production conditions, including the mistakes and failures no protocol can fully eliminate.

Conclusion

SHRINCS tackles a real long-term engineering question: how Bitcoin might move toward signatures designed for a post-quantum world without creating unacceptable operational risk. Using SHA-256 is a conservative choice, but the stateful path shifts real responsibility onto wallet reliability, while the stateless fallback comes with a significant block-space cost.

This proposal should be assessed as a complete system, not just by what the cryptography claims. Before adoption, it needs rigorous review, wallet implementations that handle uncertain state safely, and realistic analysis of fees and capacity. For Bitcoin users and developers, the bottom line isn't whether quantum readiness matters. It's whether this specific trade-off can be made safe and workable at scale.

Frequently Asked Questions

No. SHRINCS is an emerging proposal with a draft Bitcoin Improvement Proposal and a security analysis under review. It has not been adopted as a Bitcoin standard. Its specification, implementation requirements, and network trade-offs still need feedback and testing from the wider ecosystem.
SHRINCS is a hash-based signature scheme that uses SHA-256 as its security foundation. SHA-256 is already used in Bitcoin, so the proposal takes a conservative approach to its cryptographic assumptions. That familiarity does not remove the need for independent analysis of the scheme and its implementation.
The stateful path relies on one-time signing keys, which must not be reused. If a wallet accidentally uses the same state more than once, the security assumptions can fail and funds could be at risk. Wallet software therefore needs to track state reliably and use the stateless fallback when state may be compromised.
Not automatically. Its larger signatures use more block space, which could raise transaction costs when demand for block space is high. The actual impact would depend on adoption, wallet use of each signature path, network demand, and any design optimizations. Widespread stateless use would present the greatest size concern.

Related articles