# Benchmarking SPHINCS-like signatures on hardware wallets and MPC

- URL: https://research.projecteleven.com/articles/sphincs-g-benchmarks
- Published: 2026-11-16
- Authors: Alessandro Baiocchi, Matteo Vicari
- Categories: Cryptography, Hash-based

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.

---

## 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 $2^{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](https://sphincs.art/)), and [leanSPHINCS](https://cointelegraph.com/news/ethereum-quantum-proof-accounts-7-cents-researcher) aims to lower verification cost further through aggregation. Our parameter sets follow the same idea, with budgets of $2^{24}$ to $2^{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 $q_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 $B$ FORS instances in advance, then searches for a randomizer $R$ whose digest lands on one of them.

A signature goes through four phases:

1. **Precompute.** Prepare $B$ 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 $R$ until the digest selects a prepared leaf. This takes about $2^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 ($q_S$). With $B = 32$, a signature needs on average $2^{19}$ (about 524,000) attempts at $q_S = 2^{24}$ and $2^{21}$ (about 2.1 million) at $q_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](https://github.com/SHRINCS/shrincs-bip/blob/main/SHRINCS.md), 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 |
| $q_S = 2^{24}$             | 262,144 |  2,047 |          264,191 |              280,575 |                32.0 |
| $q_S = 2^{26}$             | 262,144 |  2,047 |          264,191 |              280,575 |                32.0 |
| $q_S = 2^{28}$             | 262,144 |  2,047 |          264,191 |              280,575 |                32.0 |
| $q_S = 2^{30}$             | 262,144 |  2,047 |          264,191 |              280,575 |                32.0 |
| $q_S = 2^{32}$             | 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

$q_S = 2^{24}$
No
347,065
14,745
361,810
382,284

Yes
85,177
12,709
97,886
101,992

$q_S = 2^{26}$
No
351,161
16,789
367,950
388,425

Yes
89,273
14,753
104,026
108,133

$q_S = 2^{28}$
No
376,761
29,588
406,349
426,826

Yes
114,873
27,552
142,425
146,534

$q_S = 2^{30}$
No
442,297
30,100
472,397
496,970

Yes
180,409
28,064
208,473
216,678

$q_S = 2^{32}$
No
573,369
31,124
604,493
637,258

Yes
311,481
29,088
340,569
356,966

### Grinding

Each attempt hits with probability $B/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 ($H^{\mathrm{grind}}$ and $H_{\mathrm{msg}}$), or 4–6 SHA-256 compressions for a 32-byte message. $h = 24$, $26$ and $28$ are the hypertree heights of the $q_S = 2^{24}$ to $q_S = 2^{32}$ sets.

$h$
$B$
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

![Grinding cost vs. B](https://research.projecteleven.com/images/sphincs-g-benchmarks/grinding-cost.svg)

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

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

| 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 $q_S = 2^{24}$, Sphincs-G lean v5 0.1.0 for $q_S = 2^{30}$                                               | 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](https://sparecores.com/server/hcloud/cpx32) 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 $h$ (layers) | FORS                  | One-time signature | Signature size |
| :------------- | :---------------------------: | :-------------------- | :----------------- | -------------: |
| $q_S = 2^{24}$ |        24 (10 + 7 + 7)        | 19 trees of height 9  | WOTS+C, $w = 4$    |        6,524 B |
| $q_S = 2^{30}$ |        26 (10 + 8 + 8)        | 24 trees of height 10 | WOTS+C, $w = 4$    |        7,740 B |

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

The Ledger runs keep $B = 32$ prepared slots and the MPC runs keep $B = 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 $q_S = 2^{24}$ and 21 at $q_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 $q_S = 2^{24}$, and in 15.06 s instead of 41.24 s at $q_S = 2^{30}$. In the 2-of-3 MPC it signs in 0.53 s at $q_S = 2^{24}$ and 0.81 s at $q_S = 2^{30}$.

### Signing time

Signer
Parameter set
SPHINCS-like (s)
SPHINCS-G (s)
Speedup

Ledger Nano S+
$q_S = 2^{24}$
19.52
0.53 (4.35)\*
36.8× (4.5×)\*

$q_S = 2^{30}$
41.24
0.81 (15.06)\*
50.9× (2.7×)\*

2-of-3 MPC
$q_S = 2^{24}$
92.2
0.53
174.0×

$q_S = 2^{30}$
134.8
0.81
166.4×

Laptop (hot wallet)
$q_S = 2^{24}$
0.078
–
–

$q_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.

| Step                                               | $q_S = 2^{24}$ (20 signatures) | $q_S = 2^{30}$ (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 $q_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 $q_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 $2^{20}$ attempts, about 10–11 s with one $2^{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

| Operation                                                  | $q_S = 2^{24}$ | $q_S = 2^{30}$ |
| :--------------------------------------------------------- | -------------: | -------------: |
| 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 $q_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 $q_S = 2^{24}$ and 40.78 s at $q_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 = 64$:

| Signing step      | $q_S = 2^{24}$ | $q_S = 2^{30}$ |
| :---------------- | -------------: | -------------: |
| 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
$q_S$
Time (mean)
Network per party

Key generation (once, top tree cached)
$2^{24}$
177.5 s
15.1 GB

$2^{30}$
177.5 s
15.1 GB

Prepare one slot (top tree cached)
$2^{24}$
36.5 s
4.53 GB

$2^{30}$
74.3 s
9.45 GB

Key generation + 64 slots
$2^{24}$
44.5 min
305 GB

$2^{30}$
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 $q_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 $q_S = 2^{24}$, while at $q_S = 2^{30}$ the slowdown is significant.
