The First Payment Using a Quantum-Safe Signature on Ethereum Classic

A payment on ETC authorised by a leanSPHINCS signature, a hash-based post-quantum scheme, and checked by an ordinary contract with no fork. We made it with skinnyCAT, an educational demo, not a production app. How the app works, how the signature works, what it costs and what ETC would need to do better.

· Istora Mandiri

On 2026-11-16 00:52:16 UTC, in block 25,742,237, a payment on Ethereum Classic was authorised by a leanSPHINCS signature, a hash-based signature that a quantum computer can’t forge, and a contract on chain checked it. As far as we can find, it’s the first payment on ETC made with a quantum-safe signature. The transaction is 0x120ca292…c4ad, and it carries this memo.

The first payment using a quantum-safe signature on Ethereum Classic, by Classix.dev

Bitcoin’s first purchase was two pizzas. Ours was Schrödinger’s pizza slice, which is in a box nobody has opened, so it may or may not exist.

We made it with skinnyCAT, a demo app that is deliberately a bit silly. Two cats, Alice and Bob, get leanSPHINCS keys made in your browser. Alice pays Bob. Bob is a skinny stray with no ETC to his name, and he pays her back anyway.

In that first transaction Alice deposited 0.01 ETC and sent Bob 0.004 scETC. A minute later Bob sent 0.001 scETC back with the memo “Code is Law”, and paid the wallet that relayed it a fee of 0.0015 ETC out of his scETC. He then withdrew 0.0001 ETC to an ordinary address.

The skinnyCAT page on Ethereum Classic mainnet with Alice's and Bob's keys made and both holding 0 scETC. Under Alice Deposits and Pays Bob, a deposit of 0.01 ETC, 0.004 scETC to Bob and the first payment message, above a checklist with a 7,740 byte signature that the on-chain verifier returned true for, waiting on the browser wallet. Beside it the wallet's transaction request for 0.01 ETC to the scETC contract with a network fee of 0.0004 ETC
The first payment at 2026-11-16 00:52 UTC, signed and checked, waiting for the browser wallet to confirm

skinnyCAT is an educational demo, not a production app. Nothing in it is audited, and it’s only meant for tiny amounts. We built it to make that first signature and so that anyone can make one of their own.

The skinnyCAT page, headed Quantum-Safe Payments on Ethereum Classic, with a notice that it is an educational demo and not a production app, then a card titled The First Payment with the date, the block, the memo and links to the three transactions, above four numbered cards, Two Cats Two Keys, Browser Wallet, Alice Deposits and Pays Bob, and Bob Pays Back Without ETC
skinnyCAT before any keys are made, with the record of the first payment above its four steps

The site is there to teach. Under the demo it explains how a quantum-safe signature works, starting with a Like I’m Five version in which a hash function is a magic blender. Fruit goes in and a smoothie comes out, anyone can blend the same fruit and check they get the same smoothie, and nobody can turn a smoothie back into fruit.

The first scene of skinnyCAT's explainer, titled The Magic Blender, with a cat beside a blender and a glass labelled smoothie, and a box headed What it is for real that reads A hash function, Keccak-256
The first scene of the site's Like I'm Five explainer. Each scene has a box saying what it is for real.

Quantum-safe here means a quantum computer can’t spend the funds. The gas is still paid by an ordinary account, which only risks its own gas money. We come back to that below, because it’s the most interesting part.

Every ordinary ETC account signs with ECDSA. The first time it signs, its public key goes on chain, and Shor’s algorithm run on a large enough quantum computer recovers the private key from that public key. On 2026-10-08 we measured how much ETC sits behind keys that have already signed, in How Much ETH and ETC Sits Behind Exposed Public Keys, and it came to 132.0M ETC, which is 83.3% of the supply.

Make Your Own

We made the first signature with skinnyCAT, and you can make one of your own at skinnycat.classix.dev with tiny amounts. The page has four steps. It makes two leanSPHINCS keys in your browser, one for Alice and one for Bob. You connect an ordinary browser wallet, which the page calls the cat courier, and it pays the gas and submits transactions without being able to move a cat’s funds or change what a cat signed. Alice then deposits ETC and pays Bob in one transaction, with a message you can edit. Last, Bob, who holds no ETC, signs a note paying Alice back, and the courier submits it for the fee Bob signed.

When the contract accepts a signature, the box opens and the cat jumps out, and if anything was changed on the way the box stays shut. The cat is Schrödinger’s, skinny enough to slip out of the box, and that’s the whole joke. Hashes protect the funds, and superposition has nothing to do with it.

We haven’t repeated the rest here. The site also has an animated walk through a real signature that you can redraw from your own message, a diagram of who signs and who pays in each step, and sections on how a key wears out, frame transactions, signature aggregation and the current limits.

What’s Under It

The cats hold scETC, wrapped ETC in a ledger contract that only leanSPHINCS keys can move. You deposit ETC to a key, and from then on every transfer or withdrawal is a message signed by that key, which anyone can submit. The contract and its verifier are ordinary EVM code that stays inside the opcodes of Spiral, ETC’s latest fork, so none of this needed a fork.

The design is Tom Wambsgans’ leanSPHINCS as EthLib specifies it. A signature is 7,740 bytes, about 119 times the 65 bytes of an ECDSA signature, and on ETC today it takes about 123,000 gas of calldata and another 86,000 to verify.

The first payment used 337,467 gas for the deposit and the transfer together, which cost about 0.000337 ETC at 1.00001 gwei. Bob’s payment back used 292,748 gas and his withdrawal 302,407. The ledger is scETC at 0x1824…2909 and the verifier is at 0xafdA…e13d. We deployed both on 2026-11-16, a few minutes before the payment, and neither has an owner or an admin.

What It Doesn’t Do

Nothing here is audited. We wrote the verifier and scETC ourselves, and the verifier follows a spec that changed five days after it was merged. Don’t put in more ETC than you’re willing to lose.

The parameters aren’t final either, because the leanSPHINCS competition hasn’t picked a scheme yet.

The courier still signs with ECDSA. Its key can’t move a cat’s funds, but a quantum attacker who holds it can spend the courier’s own ETC, and getting ETC into scETC in the first place takes an ordinary ECDSA transaction too.

And this protects only what sits in scETC. Every other ETC account still signs with ECDSA, so the 132.0M ETC behind exposed keys is as exposed as it was before. Protecting all of it takes a protocol change through an ECIP, and when Ethereum settles on a scheme we think ETC should take the same one.

Checking We’re First

Our claim is the first payment made with a quantum-safe signature, which is narrower than the first quantum-safe transaction. A contract that pays whoever reveals the preimage of a hash is quantum-safe too, and we’d expect ETC to have seen some of those.

We looked for an earlier post-quantum signature of any kind, hash-based or lattice-based, in the public copy of the whole ETC chain that we keep in BigQuery (it’s described in Ethereum Classic Is Back in BigQuery). We ran the search on 2026-11-11, before we sent ours. A signature checked on chain leaves two traces, the contract that verifies it and the transaction that carries it.

A lattice verifier can’t hide. Falcon does its arithmetic modulo 12289 and ML-DSA modulo 8380417, so the number has to be in the contract’s code. No contract ever deployed on ETC uses either one that way.

SQL Query: Contracts That Use a Lattice Modulus
-- Contracts whose code pushes the Falcon modulus 12289 (0x3001) into MOD, ADDMOD
-- or MULMOD, holds either modulus as a 32-byte constant, or contains the ML-DSA
-- modulus 8380417 (0x7fe001) at least twice. One row per distinct bytecode.
SELECT ANY_VALUE(address) AS sample_address, COUNT(*) AS deployments,
  MIN(block_timestamp) AS first_deployed
FROM (
  SELECT address, block_timestamp, bytecode,
    ARRAY_LENGTH(REGEXP_EXTRACT_ALL(bytecode,
      '613001(?:[89][0-9a-f]){0,3}0[689]')) AS falcon_mod_use,
    REGEXP_CONTAINS(bytecode, '7f0{60}3001') AS falcon_push32,
    REGEXP_CONTAINS(bytecode, '7f0{58}7fe001') AS mldsa_push32,
    DIV(LENGTH(bytecode) - LENGTH(REPLACE(bytecode, '7fe001', '')), 6) AS mldsa_any
  FROM `classix-etc-data.crypto_ethereum_classic.contracts`
  WHERE LENGTH(bytecode) > 2 + 2 * 300
)
WHERE falcon_mod_use >= 1 OR falcon_push32 OR mldsa_push32 OR mldsa_any >= 2
GROUP BY FARM_FINGERPRINT(bytecode)
ORDER BY first_deployed

A hash-based verifier looks like any other code, so for those we went after the signature. Every post-quantum signature is several hundred bytes of random-looking data, and ordinary call data is mostly zero padding. We pulled every transaction in ETC’s history that carries 400 bytes or more of dense data, or a long array of small numbers.

SQL Query: Transactions Carrying Signature-Shaped Data
-- Transactions of every era whose call data has (a) 400+ bytes in runs of 48 or
-- more non-zero bytes, with 150+ bytes at 0x80 or above, or (b) 200+ ABI words
-- holding a one or two byte value. Plain contract creations are dropped.
SELECT * FROM (
  SELECT block_timestamp, SUBSTR(input, 1, 10) AS selector,
    DIV(LENGTH(input) - 2, 2) AS bytes,
    (SELECT IFNULL(SUM(BYTE_LENGTH(x)), 0)
       FROM UNNEST(REGEXP_EXTRACT_ALL(FROM_HEX(SUBSTR(input, 3)), b'[^\\x00]{48,}')) x) AS dense,
    BYTE_LENGTH(FROM_HEX(SUBSTR(input, 3)))
      - BYTE_LENGTH(REGEXP_REPLACE(FROM_HEX(SUBSTR(input, 3)), b'[\\x80-\\xff]', b'')) AS high,
    ARRAY_LENGTH(REGEXP_EXTRACT_ALL(FROM_HEX(SUBSTR(input, 3)),
      b'\\x00{30}(?:[^\\x00][\\x00-\\xff]|\\x00[^\\x00])')) AS small_words
  FROM `classix-etc-data.crypto_ethereum_classic.transactions`
  WHERE LENGTH(input) >= 2 + 2 * 400
    AND NOT REGEXP_CONTAINS(SUBSTR(input, 1, 24), '^0x(?:60[0-9a-f]{2}|61[0-9a-f]{4})6040')
)
WHERE (dense >= 400 AND high >= 150) OR small_words >= 200
ORDER BY block_timestamp

That returned 14,264 transactions from 2015-08-07 to 2026-11-03, and we accounted for all of them. They are files and text stored on chain, an item registry, the SmartPool mining pool, a bridge whose withdrawals carry ECDSA signatures, contract creations and token airdrops. None of them checks a post-quantum signature. A second search for signatures built on short hashes found 1,389 transactions and nothing either, and no contract had our verifier’s function selector before ours.

The search can’t see a signature under 400 bytes, one assembled from contract storage or one split across several transactions. If you know of an earlier post-quantum signature on ETC, tell us and we’ll correct this post.

What ETC Does Next

The first payment moved 0.004 scETC between two cats and cost about 0.0003 ETC in gas. ETC can check a quantum-safe signature today, in ordinary contract code, with no fork. The 132.0M ETC behind exposed keys is a bigger job, and it goes through an ECIP. We’ll say more about how we think ETC gets there in our 2027 pathway, which we’ll announce next month. Until then, go to skinnycat.classix.dev and make a signature of your own.

Credits

skinnyCAT stands on other people’s work.

  • sphincs.art by Tom Wambsgans, the leanSPHINCS design, with the spec note and the Lean 4 proofs in TomWambsgans/sphincs.art.
  • EthLib, the normative leanSPHINCS spec and its test vectors.
  • SPHINCS- by Nicolas Consigny, whose leanSPHINCS verifier our own follows.
  • leanSPHINCS for developers, the Devcon 8 workshop where Matteo Vicari and Alessandro Baiocchi of Riva Labs had developers send a post-quantum transaction of their own on the Daisugi testnet. The recording is on YouTube. Baiocchi’s Devcon_Workshop repo has an LLM build the signer page, and skinnyCAT follows its flow. Its verifier uses MCOPY, a Cancun opcode, so it won’t run on ETC as compiled, which is one reason we wrote our own.
  • Post-Quantum-AA-Infra by Riva Labs.
  • SPHINCS Playground by Project Eleven, “A gamified explainer of SPHINCS+ and SPHINCS G few-time signatures”, which was on screen in that workshop.
A slide titled Producing the key at the leanSPHINCS for developers workshop. It says users can keep the same seed phrase and derive the LeanSPHINCS public key instead of ECDSA, beside a diagram of three SPHINCS+ layers over seven FORS trees.
Our view from the leanSPHINCS for developers workshop at Devcon, 2026-11-05