Lighter lost 10,393,056.79 USDC in a single transaction on November 16, 2026, and the smart contract that paid it out did exactly what it was told.

That detail is the whole story. The attacker did not find a bug in the rollup, break a proof, or manipulate an oracle. They recovered a market maker’s API private key from the market maker’s own signatures, then used the exchange’s own features to walk the money out. Lighter says the protocol, contracts and official SDKs were untouched. Everything that failed was credential handling around them.

Here is what happened, what the pool trick actually did, and what an API key can and cannot do on a venue like this.

What happened, in order

All times UTC, November 16, 2026.

  • 10:11:47 — a transaction sends 10,393,056.79 USDC from Lighter’s ZkLighter rollup contract (0x3B4D794a66304F130a4Db8F2551B0070dfCf5ca7) to 0xb3fffca23d4444eE73349825ACD84f7b5020e387. I checked the receipt directly against Ethereum: the transfer is the only USDC inflow to that address in the surrounding window. Transaction hash: 0x5b6f27ded0e9a66ef6fa107083e28db9914e46d7635cc5112d760b9cb2f958c9.
  • 11:02 — Lighter suspends all withdrawals and pool creation “as a precaution,” saying it is investigating an incident involving a single compromised external party. No numbers yet.
  • 12:49 — Lighter’s update names the cause: a leaked API key for a specific trader’s account. Guardian Mode is enabled on the contract, withdrawals stay paused, and the team publishes the attacker’s address.
  • 18:21 — deposits and withdrawals return to normal after the Lighter Security Council deactivates Guardian Mode.
  • November 17, 02:43 — GoPlus publishes the technical breakdown: nonce reuse in the victim’s custom signing code, two affected accounts, and the exact sequence used to move funds.

Two accounts are involved. GoPlus lists account 714710 (on-chain address 0x0d1D09312665D31Ed68231b88079a245E0458F6F, about $10.39M affected) and account 714723 (0x66Cf2f85115CC20bF439720927C1f93De9672068, about $5.09M). The attacker acted through account 769455, whose L1 address is the wallet above. On-chain analyst 0xTria had flagged that wallet the same morning, noting it had been funded with about $10,000 through a bridge roughly half an hour before the withdrawal.

Why the Lighter exploit is credentials, not code

If you only remember one thing about this incident, make it this: nothing was hacked. Four ordinary features were composed in the wrong order.

Lighter’s documentation is unusually clear about what an API key can do. A key belongs to one account index, can trade, and can trigger a secure withdrawal — which only ever pays back to the L1 address that owns that account. A key alone cannot transfer funds to a different L1 address; that needs the wallet’s signature.

But per Lighter’s docs, transfers between accounts under the same L1 owner do not need that signature, and a pool created by the victim’s account counts as the victim’s own account. That is the hole in the fence, and it is a designed one.

The sequence GoPlus describes:

  1. Using the compromised API key, close the victim’s open positions so their exposure becomes plain USDC.
  2. From the victim’s account, create a public liquidity pool with a 0% trading fee.
  3. Deposit about $10,000 of the attacker’s own money into that pool, minting close to 99.99% of its shares.
  4. Move the victim’s USDC into the pool in roughly $1M batches. This raises the pool’s net asset value without giving the victim matching shares.
  5. Redeem the attacker’s shares at the inflated NAV.
  6. Withdraw the proceeds to the attacker’s L1 address.

Each step is a normal product feature: closing a position, creating a pool, depositing, transferring, redeeming, withdrawing. The pool’s share pricing trusted that moving assets in and out was the account owner’s business. The account owner’s key was in someone else’s hands.

That is why “the protocol was not affected” and “a user lost $10 million” are both true statements at the same time. Liquidity pool accounting is user-facing product surface, not an implementation detail.

Root cause: a nonce, not a contract

GoPlus’s finding is that the affected accounts used insecure, unofficial signing code that reused cryptographic signing nonces across different transactions. Lighter’s response matches: the leak came from a trader’s own signing implementation, not from the platform.

The math is old and unforgiving. ECDSA signatures are built from a random value k, unique per message. If the same k signs two different messages, the two signatures (r, s1) and (r, s2) share the same r, and anyone can compute:

k = (z1 - z2) / (s1 - s2)

and then the private key from k. No brute force, no side channel, no quantum computer. Just two signatures and a division.

Note the trap for integrators: a signing nonce is not a transaction nonce. Transaction nonces can increment predictably. The ECDSA nonce must never repeat, and must never be derived from a timestamp, a counter or a cached value. GoPlus’s recommendation is the correct one — do not write this code yourself, and if you already have, rotating the key matters more than fixing the file, because keys are already recoverable from signatures that have been published.

If a leaked private key is the whole failure, the useful question is not “how did the attacker get in” but “what could that key still do once it was out.” Here, the answer included pool transfers.

What I could verify on-chain

Reported numbers and on-chain numbers diverge often enough that it is worth separating them.

Verified directly against Ethereum mainnet:

  • One token transfer of 10,393,056.79 USDC from the ZkLighter contract to the flagged address, in block 26,426,910, timestamped 10:11:47 UTC on November 16.
  • The payout transaction (0x5b6f…58c9) succeeded, and the same transaction emitted the rollup contract’s own withdrawal event.
  • The flagged address is a normal externally owned account, not a contract.

At the time of writing the same wallet still holds 3,404.3997 ETH, which at Coinbase’s spot price of $1,826.57 is roughly $6.22M. Its nonce is 29, meaning the wallet has sent 29 transactions in total — consistent with an attacker who consolidates rather than sprays. The gap between $10.39M in and roughly $6.2M still sitting there is not evidence of recovery; it reflects how much was swapped and moved on, and Ether’s price on the day you read this.

Reported, not independently confirmed by me:

  • The second account’s $5.09M and the $15.48M total. GoPlus labels these as reported figures and Lighter has not published a per-account breakdown.
  • About $5M in USDC recovered by the Lighter Security Council and returned to the affected trader. Lighter’s public posts confirm Guardian Mode was used to recover “funds involved in an additional withdrawal attempt,” without a number.
  • Downstream routing: analysts describe the USDC swapped to ETH through CoW Swap, split into tranches, bridged in part to Arbitrum, and some proceeds used to buy XMR1 on Hyperliquid. GoPlus explicitly warns that XMR1 is not native Monero and that the evidence does not establish a Monero price effect — a useful reminder that “funds went to privacy coins” is a claim, not a finding.

Why the “small” details matter more than the total

Two numbers in this incident will be quoted for a long time, and both are wrong in instructive ways.

The first is the loss figure. Lighter’s initial statement described a “single compromised external party,” which is accurate and, to a trader with money on the venue, useless. The amount that matters to a depositor is not what an attacker took from a market maker; it is whether their own withdrawal clears. Learn to read exchange statements for the sentence that names the affected balance sheet, and to ignore the adjective.

The second is recovery. Guardian Mode, the Security Council, frozen funds and returned USDC are all real, and they are also a reminder that perp DEXs increasingly ship an emergency brake plus a multisig that can use it. That is good engineering. It is also a trust assumption: the same council can freeze your withdrawals for a day while it sorts out someone else’s incident. Lighter’s halt lasted about seven hours. Judge venues on how they communicate during a halt, because that is the only part you experience.

Practical defense: treat API keys like bearer cash

If you trade programmatically, or hand a bot your keys, treat those credentials less like a password on a hot wallet and more like cash in a bearer bond. This section is the part to act on.

Never write your own signing code. Use Lighter’s official Python, Go or TypeScript SDKs, or its Agent Kit. This is not vendor preference; it is the difference between a reviewed nonce and a bug that leaks your key the first time you sign twice.

Isolate by account, not by intention. One sub-account per strategy, funded with what that strategy needs, is the only version of “I’ll be careful” that survives a compromised key. Lighter keys scope to a single account index, which makes this cheap to do.

Rotate on suspicion, not on proof. If any code path might have reused a signing nonce, revoke the key and register a new one today. Fixing the code first, in that order, is backwards: the old signatures are already public.

Separate permissions where the venue allows it. GoPlus’s recommendation is to split trading, transfer, pool creation and redemption permissions, and to use IP allowlisting where available. If a venue forces one key to do everything, that is a risk parameter you are accepting.

Lock the exit. On Lighter, a secure withdrawal can only return funds to the account’s own L1 address, which is why the attacker withdrew rather than transferring out. Make sure your L1 owner address is a cold one, and treat any change to it as an incident.

Watch for the shape, not the amount. Pool creation followed by large transfers into that pool and an immediate redemption is a pattern you can alert on. Most monitoring tools watch withdrawals. The money left through a feature that looked like a deposit.

Limitations

Lighter has not published a full post-mortem. The account-level split ($10.39M / $5.09M), the recovery total, and the fund routing all come from third parties — GoPlus, 0xTria and the analyst community — and could change.

Nothing here implies that every Lighter account was exposed, or that the venue’s user funds as a whole are impaired. The incident as described concerns two market-maker accounts and the pool mechanics available to them.

And one thing this incident does not prove: that self-custody trading venues are uniquely unsafe. The same class of failure — a leaked credential with too much power, no second check, and a withdrawal path — is exactly what took down Binance’s hot wallet signing setup weeks earlier, and what leaked keys did to Keplr and Web3Auth social logins. The venue changes. The failure mode does not.

What to take away

The Lighter exploit is a $10.4 million lesson in the difference between “our contracts are secure” and “your funds are only as safe as the credential that can move them.”

If you operate a trading bot: switch to the official SDK this week, rotate any key you cannot prove was generated safely, and cap what a compromised key could reach.

If you deposit into pools: read how shares are priced, and ask what a compromised account can do to NAV.

If you run a venue: require a wallet signature for anything that moves value between accounts, including pool transfers, and stop exposing API signatures publicly. Lighter appears to have done both after the fact. The cheaper time to do it was before.

Frequently Asked Questions

Was the Lighter exploit a protocol hack?

No. Lighter says the incident came from a leaked API key for a specific trader's account, and that the protocol, smart contracts and official SDKs were unaffected. GoPlus traced the leak to nonce reuse in the victim's custom signing code. The rollup worked as designed; the credentials that signed for it should not have been recoverable.

How did a trading API key turn into a $10.4 million withdrawal?

Lighter API keys can trade and can trigger a secure withdrawal, which only pays back to the L1 address that owns the account. What an API key cannot do on its own is send funds to a different L1 address. The attacker did not need that: per Lighter's docs, transfers between accounts under the same L1 owner need no wallet signature, and a pool created by the victim's account counts as the victim's own account. So the attacker built a pool from the compromised account, took almost all of its shares for about $10,000, moved the victim's USDC into the pool, then redeemed the shares and withdrew the proceeds.

What was the actual bug in the victim's code?

Nonce reuse in ECDSA signing. If two different messages are signed with the same secret nonce k, anyone holding both signatures can solve for k, and from k the private key. That is a 2010-era failure, and it survived because the victim's team wrote their own signing path instead of using Lighter's SDKs. Lighter's own guidance is blunt: let the official signer handle nonces, and never substitute timestamps, counters or cached values.

How much was stolen and how much came back?

The on-chain withdrawal I verified moved 10,393,056.79 USDC in one transaction. Community analysts and GoPlus report a second account losing about $5.09M, for roughly $15.48M total, but Lighter has only publicly discussed the leaked key, not each account's balance. GoPlus reports that about $5M in USDC was recovered by the Lighter Security Council and returned to the affected trader. Treat the recovery figure as reported, not audited.

Can this happen on other perpetual DEXs?

Yes. Any venue that lets an API key move balances between accounts it controls, and that prices pool shares from an internal NAV, inherits the same shape of risk. The defense is not a bigger audit budget. It is requiring a wallet signature for pool transfers, separating trading keys from transfer permissions, and never exposing API signatures publicly, which GoPlus says Lighter now does.