Two weeks ago, a wallet that no quantum computer could ever break made a transfer on Starknet.

The transfer cost about six cents and settled on the mainnet, in public. You can look it up on the block explorer right now.

The account behind it is experimental and unaudited, built for research rather than production use. Still, real value moved through a signature no quantum computer can forge. 

That was possible because a Starknet account sets its own rules for which signatures it will accept. This wallet switched from the elliptic-curve signature the rest of crypto relies on to a quantum-resistant one on its own, with no fork, no coordinated migration, and no new address. 

That transaction is a useful place to start if you want to understand how Starknet can be upgraded for quantum-resistance.

The clock is already running

Most people in crypto know the threat in outline. A large enough quantum computer running Shor’s algorithm breaks the elliptic-curve cryptography that guards nearly every wallet in crypto, And the keys that keep your funds yours stop being secret.

What surprises people is that the quantum computer doesn’t have to exist yet for you to be exposed to it. An adversary can record encrypted blockchain data today and sit on it until the hardware catches up. The industry calls this harvest now, decrypt later. 

So the useful question is how much work stands between a chain and the day that hardware arrives. Answering it means knowing where the danger actually sits.

Why almost no chain could do what that wallet did

A blockchain has two separate exposures to quantum. 

The first is the account layer. That is the signature authorising a transaction from your wallet, and it is the one most people picture when they think about quantum risk.

The second is the verification layer. The cryptography the network uses to prove every transaction and balance is valid, the proof system sitting underneath the whole chain. Most people never think about it, and that is exactly the problem.

A quantum computer threatens both, because most chains use elliptic curves in both places. Fix one and neglect the other, and you are still exposed. A quantum-safe wallet on a chain whose proof system can be forged is a steel lock bolted to a cardboard box. 

This is why so few networks actually qualify. Bitcoin and Ethereum secure accounts with elliptic-curve signatures wired straight into the protocol, and most zk-rollups make it worse, because the SNARK proof systems they run on are built on elliptic curves too. Fixing them means rebuilding core cryptography from the inside, and on the account side it also means a coordinated migration where every holder has to move funds to a new address type before a deadline. 

Starknet begins somewhere else. 

Starknet’s Unfair Advantage 

Both of Starknet’s advantages come from design choices made years before quantum became a headline. 

Start with the verification layer. Starknet is built on STARKs, which prove computation using hash functions rather than elliptic curves. There is no known quantum attack that breaks a hash function. The best one, Grover’s algorithm, only speeds up brute-force guessing, and you cancel it out with a slightly larger hash. The layer that secures all value on Starknet was never quantum-vulnerable in the first place. That property is built into how STARKs work. 

Now the account layer, which is where that six-cent transfer from a wallet comes from. On Starknet, every account is a smart contract. No signature scheme is hardwired into the protocol. Each account decides which signatures it accepts, in its own code.

That single design choice changes everything about a quantum migration:

  • A wallet can verify post-quantum signatures, because verification is just contract logic.
  • No hard fork is required to adopt them.
  • No network-wide migration is forced. Accounts upgrade one at a time, on each owner’s schedule.
  • Accounts can swap their logic in place, keeping the same address and the same funds, so protecting yourself now does not lock you into a standard that may still change.

Working code already exists, Falcon-512 is a post-quantum signature scheme on NIST’s standardization track. S2morrow demonstrated a working Falcon-512 account written in Cairo. OpenZeppelin published deployable versions, and built the account behind that mainnet transfer.

Adopting it took no fork and no permission. If something better than Falcon comes along, moving to it will work the same way.

The rest of the road

On June 30, StarkWare published a roadmap to bring the whole network in line, in three phases.

Phase one secures all new activity. It replaces the last elliptic-curve-dependent hashing in places like state commitments and address derivation, so new transactions and contracts run on post-quantum foundations by default. This phase is already underway.

Phase two brings existing contracts forward, with tooling that lets them adopt quantum-safe storage without breaking their interfaces or forcing painful manual migrations.

Phase three moves in step with Ethereum. Two surfaces are shared with the base layer, the bridge that carries messages and assets between Starknet and Ethereum, and the data availability layer where Starknet posts its data. Both still rely on elliptic-curve cryptography inherited from Ethereum.

What matters is how much is left above that shared dependency. Ethereum’s own long-term roadmap points toward the same hash-based, STARK-friendly cryptography Starknet already runs on, so when Ethereum migrates, Starknet arrives with less remaining work than other major layer 2s.

Starknet: a head start you can use

Picture the day a real quantum computer finally arrives. On most chains, your protection is somebody else’s decision, and you wait on a protocol fork and a governance deadline to move your funds to safety. On Starknet, that upgrade was a choice you could already make, on your own timeline, with the address you always used. For institutions treating quantum readiness as a compliance question, the same property means safety on a schedule they control rather than inherit.

Read the full roadmap and follow the progress at quantum.starkware.co.