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.
Contents
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 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 to 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 . 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 FORS instances in advance, then searches for a randomizer whose digest lands on one of them.
A signature goes through four phases:
- Precompute. Prepare slots. Each slot fixes a random hypertree leaf, builds its full FORS trees and computes the hypertree signature above it.
- Grind. Try fresh values of until the digest selects a prepared leaf. This takes about attempts on average, two hash calls each.
- Reveal. Output the FORS secret values and authentication paths from the stored trees. This step hashes nothing.
- 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 (). With , a signature needs on average (about 524,000) attempts at and (about 2.1 million) at .
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 set | Private | Public | Total hash calls | SHA-256 compressions | Top-tree cache (KB) |
|---|---|---|---|---|---|
| SLH-DSA-128s | 286,720 | 1,023 | 287,743 | 292,351 | 16.0 |
| SLH-DSA-128f | 4,480 | 15 | 4,495 | 4,567 | 0.2 |
| SHRINCS stateless fallback | 286,720 | 1,023 | 287,743 | 292,351 | 16.0 |
| 262,144 | 2,047 | 264,191 | 280,575 | 32.0 | |
| 262,144 | 2,047 | 264,191 | 280,575 | 32.0 | |
| 262,144 | 2,047 | 264,191 | 280,575 | 32.0 | |
| 262,144 | 2,047 | 264,191 | 280,575 | 32.0 | |
| 262,144 | 2,047 | 264,191 | 280,575 | 32.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 set | Top-tree cache | Private | Public | Total hash calls | SHA-256 compressions |
|---|---|---|---|---|---|
| SLH-DSA-128s | No | 2,121,462 | 64,483 | 2,185,945 | 2,218,200 |
| Yes | 1,835,302 | 63,470 | 1,898,772 | 1,926,428 | |
| SLH-DSA-128f | No | 102,518 | 2,407 | 104,925 | 106,515 |
| Yes | 98,598 | 2,396 | 100,994 | 102,521 | |
| SHRINCS fallback | No | 1,597,174 | 87,017 | 1,684,191 | 1,707,229 |
| Yes | 1,311,014 | 86,004 | 1,397,018 | 1,415,457 | |
| No | 347,065 | 14,745 | 361,810 | 382,284 | |
| Yes | 85,177 | 12,709 | 97,886 | 101,992 | |
| No | 351,161 | 16,789 | 367,950 | 388,425 | |
| Yes | 89,273 | 14,753 | 104,026 | 108,133 | |
| No | 376,761 | 29,588 | 406,349 | 426,826 | |
| Yes | 114,873 | 27,552 | 142,425 | 146,534 | |
| No | 442,297 | 30,100 | 472,397 | 496,970 | |
| Yes | 180,409 | 28,064 | 208,473 | 216,678 | |
| No | 573,369 | 31,124 | 604,493 | 637,258 | |
| Yes | 311,481 | 29,088 | 340,569 | 356,966 |
Grinding
Each attempt hits with probability , 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 ( and ), or 4–6 SHA-256 compressions for a 32-byte message. , and are the hypertree heights of the to sets.
| Mean hash calls to hit (millions) | 90th percentile (millions) | 99th percentile (millions) | ||
|---|---|---|---|---|
| 24 | 8 | 4.19 | 9.66 | 19.32 |
| 16 | 2.10 | 4.83 | 9.66 | |
| 32 | 1.05 | 2.41 | 4.83 | |
| 64 | 0.52 | 1.21 | 2.41 | |
| 26 | 8 | 16.78 | 38.63 | 77.26 |
| 16 | 8.39 | 19.32 | 38.63 | |
| 32 | 4.19 | 9.66 | 19.32 | |
| 64 | 2.10 | 4.83 | 9.66 | |
| 28 | 8 | 67.11 | 154.52 | 309.05 |
| 16 | 33.55 | 77.26 | 154.52 | |
| 32 | 16.78 | 38.63 | 77.26 | |
| 64 | 8.39 | 19.32 | 38.63 |
Hash calls to hit a prepared slot, log scale; dot = mean, tick = 90th percentile, whisker end = 99th percentile. Each doubling of halves the grinding work, and the 99th percentile is 4.6× the mean. Computed from and (geometric attempts, 2 hash calls each); same values as the table above.
Every doubling of halves the expected grinding work, and every two extra levels of multiply it by four. The 99th percentile stays at 4.6× the mean throughout, so at one signature in a hundred needs more than 4.83 million hash calls of grinding at and 19.32 million at .
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.
| Platform | Hardware | Role in the benchmarks |
|---|---|---|
| Hardware wallet | Ledger Nano S+, linked to the laptop over USB. App Sphincs-G lean 0.6.0 for , Sphincs-G lean v5 0.1.0 for | SPHINCS-G signer, host-assisted. Holds the slots and runs key generation, slot preparation, the proof check and the FORS reveal |
| MPC | Three 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 parties | SPHINCS-G signer. Key generation, slot preparation and signing all run inside the MPC |
| Laptop | MacBook Pro (2026), Apple M5 Pro, with Arm SHA-256, SHA-512 and SHA-3 instructions | Host 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 set | Hypertree height (layers) | FORS | One-time signature | Signature size |
|---|---|---|---|---|
| 24 (10 + 7 + 7) | 19 trees of height 9 | WOTS+C, | 6,524 B | |
| 26 (10 + 8 + 8) | 24 trees of height 10 | WOTS+C, | 7,740 B |
For comparison, an SLH-DSA-128s signature is 7,856 B.
The Ledger runs keep prepared slots and the MPC runs keep , 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 and 21 at , 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 , and in 15.06 s instead of 41.24 s at . In the 2-of-3 MPC it signs in 0.53 s at and 0.81 s at .
Signing time
| Signer | Parameter set | SPHINCS-like (s) | SPHINCS-G (s) | Speedup |
|---|---|---|---|---|
| Ledger Nano S+ | 19.52 | 0.53 (4.35)* | 36.8× (4.5×)* | |
| 41.24 | 0.81 (15.06)* | 50.9× (2.7×)* | ||
| 2-of-3 MPC | 92.2 | 0.53 | 174.0× | |
| 134.8 | 0.81 | 166.4× | ||
| Laptop (hot wallet) | 0.078 | – | – | |
| 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.
| Step | (20 signatures) | (21 signatures) |
|---|---|---|
| Grinding on the laptop | 0.041 s | 0.164 s |
| leanVMF1 proof generation on the laptop | 1.72 s | 12.47 s |
| Proof transfer and check on the Ledger | 3.61 s | 10.87 s |
| Proof step end to end (the two rows above overlap) | 3.82 s | 14.25 s |
| FORS reveal on the Ledger | 0.49 s, 6 APDUs | 0.64 s, 9 APDUs |
| Signature assembly and check on the laptop | 0.001 s | 0.001 s |
| Total, approval to signature | 4.35 s | 15.06 s |
| Proof size | ~54.8 KB | ~167 KB |
| Attempts to first hit | 509,491; about 524k expected | 2,228,910; about 2.1M expected |
At 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 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 attempts, about 10–11 s with one 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
| Operation | ||
|---|---|---|
| Key generation (once) | 59.65 s | 59.59 s |
| Prepare one slot | 19.31 s | 40.95 s |
| Prepare one slot, layer-1 tree already known to the laptop | 12.97 s | 28.45 s |
| Slot export to the laptop | 10,684 B | 20,268 B |
Preparing a slot costs about as much as one standard signature (19.31 s against 19.52 s at ), but it runs before the next signature is requested. Filling all 32 slots the first time took 18.60 s per slot at and 40.78 s at , 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 :
| Signing step | ||
|---|---|---|
| Signature process | 0.37 s | 0.4 s |
| Grinding | 0.16 s | 0.41 s |
| Total | 0.53 s | 0.81 s |
The one-time and precompute costs, per budget:
| Phase | Time (mean) | Network per party | |
|---|---|---|---|
| Key generation (once, top tree cached) | 177.5 s | 15.1 GB | |
| 177.5 s | 15.1 GB | ||
| Prepare one slot (top tree cached) | 36.5 s | 4.53 GB | |
| 74.3 s | 9.45 GB | ||
| Key generation + 64 slots | 44.5 min | 305 GB | |
| 84.8 min | 620 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 , 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 , while at the slowdown is significant.