How fast is signing in a secure enclave? Hyperliquid signing latency, measured

On Lit Protocol's staging environment, signing a Hyperliquid order inside a secure enclave, in Hyperliquid's testnet signing formats, took a median of 135 to 140 milliseconds for a single signature. We measured it from our office on an ordinary cable connection, not from a server in the same data center, so it is the end-to-end time a real client sees, including the network round trip to Lit and back. We measured 600 requests across six Hyperliquid operations, all 600 succeeded, and every signature verified with Hyperliquid's official Python SDK v0.24.0. The benchmark action only checked its inputs before signing. Real policy checks, especially ones that fetch data, add time.

The results

All figures are in milliseconds, from sending the request to receiving the complete signed response.

Operation                           Min    Median   p95     p99     Max
Open position                       106.2  138.3    227.6   270.2   285.7
Close position (reduce-only)        100.8  135.7    205.8   350.8   935.2
Open + TP/SL, bundled               111.4  139.5    179.9   261.2   304.4
Open + TP/SL, separate signatures   116.8  152.0    203.9   245.2   330.9
Withdraw                             99.3  136.0    182.5   342.8   448.8
Transfer spot to perps              105.2  135.1    217.0   246.2   265.6

The p95 and p99 columns are the 95th and 99th percentiles. Each operation had 100 measured requests, so the p99 is close to the slowest few samples, and the minimum is the fastest sample we saw, not a guarantee. The bundled take-profit and stop-loss case signs one order batch. The separate case signs three orders inside one Lit request, and its median is about 12 milliseconds higher.

How we measured

We ran the test on 27 October 2026 on Lit's staging environment, called next, using Hyperliquid's testnet signing formats, from a single client in our office on a cable internet connection. Each operation had five warm-up requests and then 100 measured requests, with one request in flight at a time, connection reuse, and no retries. The requests used fixed market and position inputs.

The numbers cover warm request-to-signed-result latency. They do not include reading market data, submitting the order to Hyperliquid, fills, or settlement. No trades were submitted and no funds moved. This was a benchmark from one client, not a service level agreement.

All six operations used one Lit Action, a JavaScript function that runs inside the enclave. It builds the Hyperliquid action, gets the action's own key, and signs with the same formats as Hyperliquid's Python SDK. Our guide to building a Hyperliquid trading bot on Lit, which comes out on Monday, November 2, walks through a smaller, order-only action that signs with a Lit wallet.

What this means for a trading bot

About 140 milliseconds is fast enough for bots that decide on the scale of seconds, like take-profit and stop-loss management, rebalancing, funding-rate trades, and agents that act on signals. For those bots, the signature is a small part of the total time, next to reading prices and waiting for the exchange.

It is too slow for market making or latency arbitrage, where a strategy signs many times a second and the fastest option is a key in memory on a server next to the exchange. A key in memory is also exposed to anything that reaches the server.

Look at the slower requests too. For every operation, 95 percent of requests finished within about 230 milliseconds, and the slowest single request in the test took 935 milliseconds. If your strategy has a hard deadline, plan for the p99, which ranged from 245 to 351 milliseconds.

How this compares

Wallet API providers publish their own numbers. Turnkey's homepage says "50–100ms latency for signing transactions". Coinbase's documentation for its server wallets says "wallet creation and signing under 500ms." These are each company's own claims, and they do not say from where they were measured, so they are not a direct comparison with a client-side measurement like ours.

On Lit, the signing rule is your own JavaScript. It can fetch data, such as a price or a balance, before it signs, and each fetch adds to the time.

Signing with MPC works differently. Several machines exchange messages to produce each signature, which usually adds network round trips. A secure enclave signs in one place, so it avoids those extra round trips between machines.

Get started

To try it yourself, create an account at the Lit dashboard by clicking Create an account. The examples page has signing actions you can start from. The Lit Actions runtime is documented at developer.litprotocol.com/lit-actions.