The First Post-Quantum sBTC Transfer on Stacks Mainnet

Stacks Labs has completed an sBTC transfer on Stacks mainnet using a Lamport one-time signature. The signature was verified in Clarity, demonstrating a hash-based approach to post-quantum signing. This work is part of Stacks Labs' ongoing research into strengthening the Stacks network against quantum attacks.

‍View the mainnet transaction.

Why quantum computers are a risk

Bitcoin and Stacks use elliptic curve digital signatures to verify that a transaction was approved by a user holding the required private key. A sufficiently powerful quantum computer could derive that private key from its public key, allowing an attacker to forge signatures and move funds.

Post-quantum cryptography addresses this risk with methods designed to resist known quantum attacks. Hash-based signatures are one of those approaches. NIST's overview explains the cryptography in more detail.

Clarity, Stacks' smart contract language, already has the hash functions needed to test this approach. Stacks engineers used them to build a vault that requires a Lamport signature before releasing funds, without a protocol upgrade.

How Lamport signatures work

Lamport signatures use secret values and their hashes. A hash is easy to calculate, but recovering the original input from it is computationally difficult.

To sign a message, the software hashes it into a fixed-length digest. The digest determines which secret values to reveal. The verifier hashes those values and checks that they match the public-key information currently stored in the vault.

Stacks Labs' implementation uses SHA-256. The Lamport format specification documents how the keys and signatures are constructed.

Lamport signatures are much larger than elliptic curve signatures. For this work, engineers chose Lamport because its straightforward design makes signing and verification easier to review. The team continues to evaluate potential signature schemes for Stacks’ transition to post-quantum security.

How the transfer is protected

The signed message specifies which vault to spend from, the asset and amount, the recipient, and the key to use next. It is also bound to the chain, contract and current transfer counter. Changing those details invalidates the authorization.

A separate Stacks account submits the message and pays the transaction fee. The vault checks the Lamport signature before releasing the sBTC to the recipient named in the message.

Each Lamport key can safely sign only one distinct message. Reusing it for a different message reveals more secret values and weakens its protection. The signing software records the instruction before releasing a signature and refuses to sign a different message with the same key, even after a restart. If a transaction needs to be retried, it uses the same recorded authorization.

After a successful transfer, the contract advances its counter and installs the next key as part of the same transaction. The old authorization cannot be reused for another transfer. 

What this demonstrates for Stacks

The mainnet transfer shows that a Clarity smart contract can verify a Lamport signature and use it to make sBTC transfers.

Local tests also confirmed that the vault rejects attempts to change the recipient or next key, as well as attempts to replay a completed transfer. The GitHub repository includes the contracts, signing software and evidence needed to review the work.

Stacks developers can use this prototype as a starting point for building and testing hash-based signing rules in Clarity.

What’s next 

Stacks Labs' engineers will next evaluate post-quantum signature schemes and migration approaches, starting with making the Stacks network quantum-resistant.

Because Stacks settles to Bitcoin and every sBTC is backed by BTC on Bitcoin L1, the research then extends to the quantum risk to that Bitcoin backing and to supporting Bitcoin’s own resistance to quantum attacks. Stacks Labs will share more on this work in a follow-up post later this year.