Project Eleven
Research
projecteleven.com (opens in a new tab)

Benchmarking SPHINCS-like signatures on hardware wallets and MPC

Benchmarks of SPHINCS-G, our signing variant of SPHINCS+, on a Ledger Nano S+ and in a 2-of-3 MPC: hash counts for each phase and signing times at budgets of 2^24 and 2^30 signatures per key.

View .md file
Contents
  1. Introduction
  2. How SPHINCS-G works
  3. Hash counts
  4. Key generation
  5. Signing
  6. Grinding
  7. Experimental setup
  8. Experimental results
  9. Signing time
  10. Ledger Nano S+: where the signing time goes
  11. Ledger Nano S+: precompute work
  12. 2-of-3 MPC
  13. Conclusion

Introduction

In this post we present numerical benchmarks for SPHINCS-G, our signing variant of SPHINCS+: how many hashes each phase needs, and how fast it signs on a Ledger Nano S+ and in a 2-of-3 MPC, with a laptop as reference.

Many public blockchain ecosystems, especially Ethereum, are discussing the best parameter sets for SPHINCS-like signature schemes. These discussions settle key choices, such as signature size and lifetime budget, that must support every signing scenario, including constrained hardware.

SPHINCS+, standardized by NIST as SLH-DSA, is a conservative choice for post-quantum wallets, but it is sized for 2642^{64} signatures per key. A wallet needs far fewer: on Ethereum, the 99.9th percentile of active addresses sends about 431 transactions a year, according to Dune data. Recent Ethereum work therefore cuts the budget (see sphincs.art (opens in a new tab)), and leanSPHINCS (opens in a new tab) aims to lower verification cost further through aggregation. Our parameter sets follow the same idea, with budgets of 2242^{24} to 2322^{32} signatures per key.

A smaller budget makes signatures smaller and cheaper to verify, but signing stays expensive on hardware wallets and in MPC. On a hardware wallet's limited CPU, a SPHINCS-like signature takes 19.5 s on a Ledger Nano S+ even at qS=224q_S = 2^{24}. In MPC, every hash on secret data must be computed jointly by the parties, which costs time and gigabytes of traffic. SPHINCS-G moves most of this work before the transaction arrives, so little of it is left once the user approves.

To overcome these limitations, we developed a new construction called SPHINCS-G, which we explain in the following paragraph.

How SPHINCS-G works

As a quick note for the reader, the full paper on this new construction is coming soon, followed shortly by a second one. This section gives only the background needed to read the benchmarks below.

SPHINCS-G does most of the signing work before the message is known. On a Ledger Nano S+ it cuts the time from approval to signature by 2.7–4.5×.

In SPHINCS+, the message digest selects a FORS instance at one leaf of the hypertree. The signer must build that instance and sign its root up the hypertree, so the expensive work starts only once the message arrives. SPHINCS-G instead prepares BB FORS instances in advance, then searches for a randomizer RR whose digest lands on one of them.

A signature goes through four phases:

  1. Precompute. Prepare BB slots. Each slot fixes a random hypertree leaf, builds its full FORS trees and computes the hypertree signature above it.
  2. Grind. Try fresh values of RR until the digest selects a prepared leaf. This takes about 2h/B2^h/B attempts on average, two hash calls each.
  3. Reveal. Output the FORS secret values and authentication paths from the stored trees. This step hashes nothing.
  4. Refill. Optionally, prepare a new slot to replace the one just used.

Grinding is practical only with a short hypertree, so we use parameter sets built for a bounded number of signatures per key (qSq_S). With B=32B = 32, a signature needs on average 2192^{19} (about 524,000) attempts at qS=224q_S = 2^{24} and 2212^{21} (about 2.1 million) at qS=230q_S = 2^{30}.

The grinding can run on the signer itself or on an untrusted host. In the host-assisted mode used on the Ledger, the laptop grinds and sends a STARK proof that its hit is the first one in the search. The wallet checks the proof, then reveals the FORS values.

Hash counts

We start our benchmarks with hash counts.

Hash counts give the cost of each phase independently of hardware and implementation.

We differentiate private from public hash function calls in the following way:

  • private calls take at least one secret as input.
  • public calls only have public values as inputs.

This is relevant because private hashes need more attention and are usually more expensive than public hashes, and in constrained setups this distinction can make a sensible difference.

SHA-256 compressions count hash blocks rather than calls, since some calls hash more than one block. The SLH-DSA rows are baselines, and the SHRINCS row is the current proposal for the stateless fallback of the SHRINCS draft BIP (opens in a new tab), the hash-based scheme for Bitcoin from Blockstream Research.

Key generation

Key generation builds only the top layer's Merkle tree. Keeping that tree for signing takes the cache in the last column.

Parameter setPrivatePublicTotal hash callsSHA-256 compressionsTop-tree cache (KB)
SLH-DSA-128s286,7201,023287,743292,35116.0
SLH-DSA-128f4,480154,4954,5670.2
SHRINCS stateless fallback286,7201,023287,743292,35116.0
qS=224q_S = 2^{24}262,1442,047264,191280,57532.0
qS=226q_S = 2^{26}262,1442,047264,191280,57532.0
qS=228q_S = 2^{28}262,1442,047264,191280,57532.0
qS=230q_S = 2^{30}262,1442,047264,191280,57532.0
qS=232q_S = 2^{32}262,1442,047264,191280,57532.0

Signing

With the top tree cached, the top layer only computes its WOTS signature and reads its authentication path from the cache. Preparing one SPHINCS-G slot costs the same as signing, minus the message hashing: one private and one public call fewer.

Parameter setTop-tree cachePrivatePublicTotal hash callsSHA-256 compressions
SLH-DSA-128sNo2,121,46264,4832,185,9452,218,200
Yes1,835,30263,4701,898,7721,926,428
SLH-DSA-128fNo102,5182,407104,925106,515
Yes98,5982,396100,994102,521
SHRINCS fallbackNo1,597,17487,0171,684,1911,707,229
Yes1,311,01486,0041,397,0181,415,457
qS=224q_S = 2^{24}No347,06514,745361,810382,284
Yes85,17712,70997,886101,992
qS=226q_S = 2^{26}No351,16116,789367,950388,425
Yes89,27314,753104,026108,133
qS=228q_S = 2^{28}No376,76129,588406,349426,826
Yes114,87327,552142,425146,534
qS=230q_S = 2^{30}No442,29730,100472,397496,970
Yes180,40928,064208,473216,678
qS=232q_S = 2^{32}No573,36931,124604,493637,258
Yes311,48129,088340,569356,966

Grinding

Each attempt hits with probability B/2hB/2^h, so the number of attempts is geometric: the 90th and 99th percentiles are 2.30 and 4.61 times the mean. An attempt costs 2 hash calls (HgrindH^{\mathrm{grind}} and HmsgH_{\mathrm{msg}}), or 4–6 SHA-256 compressions for a 32-byte message. h=24h = 24, 2626 and 2828 are the hypertree heights of the qS=224q_S = 2^{24} to qS=232q_S = 2^{32} sets.

hhBBMean hash calls to hit (millions)90th percentile (millions)99th percentile (millions)
2484.199.6619.32
162.104.839.66
321.052.414.83
640.521.212.41
26816.7838.6377.26
168.3919.3238.63
324.199.6619.32
642.104.839.66
28867.11154.52309.05
1633.5577.26154.52
3216.7838.6377.26
648.3919.3238.63

Hash calls to hit a prepared slot, log scale; dot = mean, tick = 90th percentile, whisker end = 99th percentile. Each doubling of BB halves the grinding work, and the 99th percentile is 4.6× the mean. Computed from hh and BB (geometric attempts, 2 hash calls each); same values as the table above.

Every doubling of BB halves the expected grinding work, and every two extra levels of hh multiply it by four. The 99th percentile stays at 4.6× the mean throughout, so at B=32B = 32 one signature in a hundred needs more than 4.83 million hash calls of grinding at h=24h = 24 and 19.32 million at h=26h = 26.

Experimental setup

We ran SPHINCS-G on two signers, a Ledger Nano S+ and a 2-of-3 MPC cluster. As a hot-wallet reference, we timed standard SPHINCS+ signing on a laptop.

PlatformHardwareRole in the benchmarks
Hardware walletLedger Nano S+, linked to the laptop over USB. App Sphincs-G lean 0.6.0 for qS=224q_S = 2^{24}, Sphincs-G lean v5 0.1.0 for qS=230q_S = 2^{30}SPHINCS-G signer, host-assisted. Holds the slots and runs key generation, slot preparation, the proof check and the FORS reveal
MPCThree Hetzner Cloud CPX32 (opens in a new tab) servers, one per party: 4 shared AMD EPYC vCPUs, 8 GB RAM each. 2-of-3 threshold, about 1 ms between partiesSPHINCS-G signer. Key generation, slot preparation and signing all run inside the MPC
LaptopMacBook Pro (2026), Apple M5 Pro, with Arm SHA-256, SHA-512 and SHA-3 instructionsHost for the Ledger: grinds and generates the leanVMF1 proof. Hot wallet: runs standard SPHINCS+ signing

We benchmark two parameter sets with 16-byte hashes. Both keep a 10-layer-high top tree and use WOTS+C one-time signatures, which drop the checksum chains and grind a 4-byte counter per layer instead.

Parameter setHypertree height hh (layers)FORSOne-time signatureSignature size
qS=224q_S = 2^{24}24 (10 + 7 + 7)19 trees of height 9WOTS+C, w=4w = 46,524 B
qS=230q_S = 2^{30}26 (10 + 8 + 8)24 trees of height 10WOTS+C, w=4w = 47,740 B

For comparison, an SLH-DSA-128s signature is 7,856 B.

The Ledger runs keep B=32B = 32 prepared slots and the MPC runs keep B=64B = 64, so every signature is made with 32 or 64 slots available. On the Ledger, each configuration ran key generation, prepared 32 slots, then repeated one signature plus one slot refill: 20 signatures at qS=224q_S = 2^{24} and 21 at qS=230q_S = 2^{30}, each on a different message. Signing time runs from approval on the device to the finished signature; the time a person spends reading and approving the transaction is excluded. Every signature was checked with our verifier, and no transaction was broadcast. The Ledger runs date from 13 November 2026.

Experimental results

On the Ledger, SPHINCS-G signs in 4.35 s instead of 19.52 s at qS=224q_S = 2^{24}, and in 15.06 s instead of 41.24 s at qS=230q_S = 2^{30}. In the 2-of-3 MPC it signs in 0.53 s at qS=224q_S = 2^{24} and 0.81 s at qS=230q_S = 2^{30}.

Signing time

SignerParameter setSPHINCS-like (s)SPHINCS-G (s)Speedup
Ledger Nano S+qS=224q_S = 2^{24}19.520.53 (4.35)*36.8× (4.5×)*
qS=230q_S = 2^{30}41.240.81 (15.06)*50.9× (2.7×)*
2-of-3 MPCqS=224q_S = 2^{24}92.20.53174.0×
qS=230q_S = 2^{30}134.80.81166.4×
Laptop (hot wallet)qS=224q_S = 2^{24}0.078––
qS=230q_S = 2^{30}0.128––

– = not measured. On a laptop it makes no sense to use SPHINCS-G, as a reference hot wallet already signs in about a tenth of a second.

*The Ledger signing time is not comprehensive of the STARK proof generation, transfer and verification, the total time is shown in brackets. Alternative proof systems our team is currently testing could give even faster security checks.

Ledger Nano S+: where the signing time goes

Mean values, from approval to finished signature.

StepqS=224q_S = 2^{24} (20 signatures)qS=230q_S = 2^{30} (21 signatures)
Grinding on the laptop0.041 s0.164 s
leanVMF1 proof generation on the laptop1.72 s12.47 s
Proof transfer and check on the Ledger3.61 s10.87 s
Proof step end to end (the two rows above overlap)3.82 s14.25 s
FORS reveal on the Ledger0.49 s, 6 APDUs0.64 s, 9 APDUs
Signature assembly and check on the laptop0.001 s0.001 s
Total, approval to signature4.35 s15.06 s
Proof size~54.8 KB~167 KB
Attempts to first hit509,491; about 524k expected2,228,910; about 2.1M expected

At qS=224q_S = 2^{24} the bottleneck is the Ledger receiving and checking the proof, 3.1–3.8 s per signature; total signing ranged from 3.68 s to 5.69 s. At qS=230q_S = 2^{30} the slot index takes a second Keccak hash, so each candidate in the proof costs about twice as much, and the time depends on how late the first hit comes. Signatures took about 7–8 s when the proof had one segment of up to 2202^{20} attempts, about 10–11 s with one 2212^{21} segment, and 14–40 s when the first hit came after about 2 million attempts.

Note: much of this proof time is spent moving data from the laptop to the device. A hardware wallet manufacturer could cut it drastically by changing how data is transmitted from the host to the device.

Ledger Nano S+: precompute work

OperationqS=224q_S = 2^{24}qS=230q_S = 2^{30}
Key generation (once)59.65 s59.59 s
Prepare one slot19.31 s40.95 s
Prepare one slot, layer-1 tree already known to the laptop12.97 s28.45 s
Slot export to the laptop10,684 B20,268 B

Preparing a slot costs about as much as one standard signature (19.31 s against 19.52 s at qS=224q_S = 2^{24}), but it runs before the next signature is requested. Filling all 32 slots the first time took 18.60 s per slot at qS=224q_S = 2^{24} and 40.78 s at qS=230q_S = 2^{30}, roughly 10 and 22 minutes in total. Slot times are means over 28 and 19 refills; the layer-1 variant was measured on 4 and 2 refills.

2-of-3 MPC

Mean signing time, split by step, with B=64B = 64:

Signing stepqS=224q_S = 2^{24}qS=230q_S = 2^{30}
Signature process0.37 s0.4 s
Grinding0.16 s0.41 s
Total0.53 s0.81 s

The one-time and precompute costs, per budget:

PhaseqSq_STime (mean)Network per party
Key generation (once, top tree cached)2242^{24}177.5 s15.1 GB
2302^{30}177.5 s15.1 GB
Prepare one slot (top tree cached)2242^{24}36.5 s4.53 GB
2302^{30}74.3 s9.45 GB
Key generation + 64 slots2242^{24}44.5 min305 GB
2302^{30}84.8 min620 GB

Conclusion

SPHINCS-G helps where SPHINCS+ signing is slow or costly, as on hardware wallets and in MPC; on a laptop, standard signing already takes under 0.13 s.

On the Ledger Nano S+, it dramatically cuts the wait after approval. Each slot still costs the device about as much as one standard signature, but that work runs between transactions.

In the 2-of-3 MPC, signing takes well under a second at both budgets, and the cost moves to the offline phases. At qS=224q_S = 2^{24}, key generation and 64 slots move 305 GB per party between the servers. Since slots are prepared ahead of time, bandwidth matters more than latency for an MPC wallet.

Our benchmarks show that signing with stateless hash-based signatures on constrained setups is feasible. With the two parameter sets we measured, signing stays comfortable for the user at qS=224q_S = 2^{24}, while at qS=230q_S = 2^{30} the slowdown is significant.