TL;DR
At 03:07 UTC on November 10, 2026 (10:07 p.m. US Eastern on November 9), a newly created account on Arcus, the perpetuals exchange on Robinhood Chain, used a bug in transfers between a user's own sub-accounts to record a balance far larger than it held, then withdrew against it. Arcus says 2,234,391 USDG left on-chain and a further $3 million was held by the bridge's on-chain rate limit, never paid and later reversed, and that its treasury covered the shortfall. CertiK's analysis of the saved account records finds the fingerprint of a signed 64-bit wraparound: one internal transfer left the receiving sub-account just above the int64 floor, and a 1 USDG withdrawal then flipped it to roughly +9.2 billion. CertiK says which component did the wrapping is unresolved. Our own arithmetic on the balances CertiK published, shown below and not a derivation CertiK makes, puts the transfer amount at the largest value a signed 64-bit integer can hold. Arcus's docs say its validator set re-checks margin, and CertiK's address list shows the withdrawals published through the normal validator path. The control that held was a rate limit on the vault, which held back 57% of what the engine approved.
What Happened at Arcus?
Arcus is a perpetuals and tokenized-stock exchange that dYdX Labs created in partnership with Robinhood, with an investment from Robinhood Crypto. It runs on Robinhood Chain, which Robinhood's documentation describes as an Ethereum Layer 2 built with Arbitrum technology.
Arcus's own report gives the shape. A newly created account exploited "a bug in how the exchange handled transfers between a user's own subaccounts". Under specific conditions it could record a balance far larger than it held, and it requested withdrawals against that balance. Arcus says one account was involved and no other balances, positions or orders were affected.
The account was barely a day old. Blockint's trace shows it received its first gas, 0.091367 ETH, at 11:33:36 p.m. CST on November 8 (05:33:36 UTC on November 9), from a wallet active on Robinhood Chain since July. It bought 42.36 USDG through Relay, ran small round trips of 1 to 40 USDG through the same vault that later paid out, and traded small amounts of the SPY stock token about 90 minutes before the first large withdrawal. That is about 21.5 hours from first gas to the exploit, by our count.
How Does a Sub-Account Transfer Create a 9.2 Billion Balance?
A signed 64-bit integer holds values from -2^63 to 2^63 - 1. Push a result past either end and, in two's-complement arithmetic, it wraps around to the other end. Subtract 1 from the most negative int64 and you get the most positive one. That is integer wraparound, CWE-190 in MITRE's catalogue, and the version where a subtraction crosses the floor is usually called underflow.
CertiK's report sets Arcus's quote scale at 1e9 quantums per quote unit. One full int64 cycle, 2^64 quantums, is therefore 18,446,744,073.709551616 quote units. CertiK then lines up the saved transfer records against ordinary bookkeeping:
| Moment (UTC, Nov 10) | Account | Cash before | Reported cash after | Residual vs ordinary arithmetic |
|---|---|---|---|---|
| 03:07:10.104964, internal transfer | Source sub-account | -2,156.277510656 | +9,223,369,880.577265153 | +2^64 |
| 03:07:10.104964, internal transfer | Recipient sub-account | +0.500000944 | -9,223,372,036.354774865 | -2^64 |
| 03:08:46.831236, 1 USDG withdrawal | Recipient sub-account | -9,223,372,036.354774865 | +9,223,372,036.354776751 | +2^64 |
Read the first two rows together. Each balance is wrong by exactly one full int64 cycle, in opposite directions, so the pair still sums to -2,155.777509712, the same total as before the transfer. CertiK notes that a check that only verifies the two sides of a transfer net to zero can miss this pattern.
The third row has no opposite leg. The recipient sat just above the int64 floor, the 1 USDG debit pushed it below, and the balance came back as roughly +9.2 billion quote units. CertiK calls this signed underflow and is careful about what it proves: it is "an exact anomaly in the recorded cash transition, not evidence of additional deposited collateral".
One more number falls out of CertiK's figures, and the arithmetic is ours. Undo the wrap on the recipient's post-transfer balance and subtract its starting cash: -9,223,372,036.354774865 + 18,446,744,073.709551616 - 0.500000944 = 9,223,372,036.854775807 quote units. CertiK reports balances to nine decimals, which at 1e9 quantums per unit is the smallest unit the engine counts, so nothing here is rounded. That is 2^63 - 1 quantums: INT64_MAX, to the last digit, sent from a sub-account whose cash was negative. A value that exact reads as deliberate, which would mean the attacker knew or had probed the engine's integer width, though an engine-side clamp to the type's maximum would produce the same number. Nothing published settles which.
How that sub-account reached -2,156 is not published. CertiK notes that negative quote cash alone does not mean insolvency on Arcus, because equity also counts open positions and spot collateral. The account's small SPY trades in the 90 minutes before are one candidate, but no source connects them to the negative cash, so treat that as open.
Arcus's public transfer-update documentation says a withdrawal or transfer that exceeds free collateral should be rejected before it is persisted. CertiK quotes the same rule, accountEquity minus requiredMargin, and states plainly that the records do not show which component performed the wrapping or whether the collateral guard consumed a wrapped value. Arcus has not published the code path, and why the guard let the transfer through is the open question of this incident.
CertiK also points to Arcus's public data-availability decoder, which reads amounts and quote balances as signed 64-bit values. That supports the wire format. It does not show the engine's own arithmetic.
The Attack, Step by Step
| Step | Time (UTC) | What happened | Source |
|---|---|---|---|
| 1 | Nov 9, 05:33:36 | Fresh account receives 0.091367 ETH of gas, buys 42.36 USDG, runs 1 to 40 USDG round trips | Blockint |
| 2 | Nov 10, 03:07:10 | Internal transfer between own sub-accounts; recipient cash lands just above the int64 floor | CertiK |
| 3 | Nov 10, 03:08:46 | 1 USDG withdrawal applied; recipient cash wraps to about +9.2 billion | CertiK |
| 4 | Nov 10, 03:08:51 to 03:08:52 | Publication creates BridgeVault record 39755; vault pays 1 USDG | CertiK |
| 5 | Nov 10, 03:10:15 to 03:11:24 | Four payouts of 500,000 USDG in 69 seconds | Blockint |
| 6 | Nov 10, 03:13:50 onward | USDG goes into Relay, paid out as ETH on Ethereum | Blockint |
| 7 | Nov 10, 03:28:14 to 03:53:56 | Four smaller payouts of 55,000 to 60,919 USDG | CertiK, Blockint |
| 8 | Nov 10, 04:07 to 04:43 | Withdrawals paused, fix deployed, exploiter addresses blocked | Arcus |
Per CertiK, fifteen withdrawal requests were applied in the engine, totalling 5,234,391 USDG. Nine were paid, 2,234,391 USDG, which are the nine payouts in steps 4, 5 and 7. Six, totalling 3,000,000 USDG, which CertiK does not itemize, had no matching payout through finalized block 111,322,906, which CertiK dates to 01:13:26 UTC on November 11. Arcus attributes the held requests to its limiter and the later reversal.
Why Didn't the Validators Stop It?
Arcus is a hybrid exchange. Its architecture page describes an off-chain matching engine with a sequencer and a deterministic state machine, a permissioned validator set that "independently replicates the exchange state machine", re-verifying signatures and checking margin, a Checkpoint Manager that records withdrawals on the rootchain, and a Bridge Vault that custodies funds and honors withdrawals the validator set publishes.
On paper that is a second opinion on every balance. A replica of a deterministic state machine, though, runs the same arithmetic on the same inputs, and if the validators share the engine's integer handling they wrap with it and sign off on the result. Whether they do is not public. What is public is the outcome: CertiK's address list shows the payout path running through the validator consensus proxy and the Checkpoint Manager, so the entitlements were published through the normal route.
An account that had moved a few dozen USDG through the vault was granted entitlements of 5.2 million, and no check between the engine and the vault flagged it.
What Did the Rate Limit Actually Save?
The bridge's on-chain rate limit held 3,000,000 of the 5,234,391 USDG that CertiK counts as requested, about 57%. Arcus's timeline has the limiter capping payouts at 10:10 p.m. ET, which is 03:10 UTC.
The payout shape shows the limiter at work. After a 1 USDG test, four 500,000 USDG payouts landed in 69 seconds. After the fourth, every payout was between 55,000 and 60,919 USDG, spaced 4 to 17 minutes apart. Blockint reads it the same way. Arcus has not published the limiter's parameters, so treat the burst-then-trickle reading as inference from timing.
Arcus's monitoring flagged the withdrawals at 10:15 p.m. ET (03:15 UTC), eight minutes after onset. The pause came at 11:07 p.m. ET (04:07 UTC), 52 minutes later, and Arcus's status page posted at 04:11 UTC. In that gap the vault paid four more times: 55,000, 60,000, 58,471 and 60,919 USDG, which is 234,390 USDG by our sum. The other 2,000,001 USDG, the 1 USDG test plus the four 500,000 payouts, had left before the alert.
Arcus says it "detected and fixed the bug within one hour". Its own timeline puts monitoring at 10:15 p.m. and the fix at 11:37 p.m. ET, 82 minutes apart, a gap The Crypto Times also noted.
Where Did the $2.23 Million Go?
Blockint matched each deposit to Relay's public request records: the exploiter started sending USDG into the Relay depository two and a half minutes after the last 500,000 payout, resubmitted two refunded requests, and received 1,052.212689 ETH on Ethereum between 03:15:59 and 03:59:23 UTC.
PublicAML's trace makes the timing point that matters. USDG is a token its issuer can freeze, and ETH is not. The last Relay payout landed 44 minutes before Arcus blocked the address at 04:43 UTC. The first Relay deposit, at 03:13:50 UTC, came before Arcus's own alert.
After that, the attacker reshuffled:
- DAI. About 475.90 WETH sold through CoW Protocol for 1,008,945 DAI, moved to a fresh wallet that, as of PublicAML's read on November 11, had sent nothing.
- Bitcoin. About 101 ETH went through THORChain and Relay to one Bitcoin address, 2.831 BTC in five payments, unspent at the time.
- ETH. 475.06 ETH stayed on the exploiter's address on November 11.
On November 11, an on-chain message described as coming from Arcus offered a whitehat deal: return 90% in ETH, WETH or DAI, keep about $223,000 as a bounty, by 01:00 UTC on November 13. The Crypto Times notes the authorship is unconfirmed and Arcus's report does not mention it. As of November 18, the exploiter's address holds 0.000020024798932 ETH on Etherscan, so the 475 ETH has moved since PublicAML's snapshot. We have not traced where it went. We found no transfer from that address to the recovery address the message named, and no source we found reports a return.
Arcus says the shortfall was covered from the Arcus Labs treasury at 12:28 p.m. ET on November 10. CertiK corroborates the pause and resumption from the status record but says recovery and the treasury top-up have not been independently established. CertiK also flags a vault implementation upgrade at 08:17:05 UTC as "not proof of the reported engine fix".
Why This Matters Beyond Arcus
Integer wraparound is one of the oldest bugs in this industry. In April 2018, PeckShield's alert on BeautyChain traced an absurdly large BEC transfer to batchOverflow, CVE-2018-10299: a multiplication in batchTransfer overflowed to zero, the balance checks passed, and two receivers were credited an enormous value for free. Solidity 0.8 made arithmetic revert on overflow and underflow by default, and the class mostly left on-chain code.
Hybrid exchanges keep balances in off-chain engines written in general-purpose languages, where fixed-width integers and their overflow behavior are the programmer's problem again. The contracts get audited because they hold the money, while the engine, which decides what each account may withdraw, often sits outside that scope.
BEC was caught because a system alarmed on a transfer of "unreasonably large tokens". Arcus's ledger showed a sub-account at about -9.2 billion and then +9.2 billion within 97 seconds.
What Should Hybrid Exchange Operators Do?
- Bound every amount at the request boundary. On CertiK's balances the transfer was about 9.2 billion quote units, from a sub-account holding -2,156. A request that size should fail input validation before any margin math runs, for example by rejecting any amount larger than the exchange's total collateral.
- Make engine arithmetic fail closed. Use checked arithmetic on every balance mutation and halt the request, or the engine, on overflow.
- Give settlement a check that is written differently. A replica that re-runs the engine inherits its bugs. Put an independent invariant where the money leaves, for example "an account's withdrawals cannot exceed its lifetime deposits plus realized PnL by more than a set margin". This account had moved a few dozen USDG through the vault and asked for 5.2 million.
- Keep the vault rate limit, and size the burst for the worst day. Arcus's limiter held $3 million. The four 500,000 USDG payouts in the first 69 seconds were the burst it allowed. Per-account limits, tighter for young accounts, shrink that first bite.
- Wire the alert to the pause. Monitoring fired at 03:15 UTC and the pause came at 04:07 UTC. A pre-authorized on-call pause, or an automated hold on withdrawals when an alert fires, would have covered the 234,390 USDG paid in between.
Could Monitoring or an Audit Have Caught It?
Only Arcus could have seen the earliest signals, because they lived in its own ledger. Its monitoring flagged withdrawals at 03:15. A rule on ledger balances instead, for example any sub-account beyond plus or minus one billion quote units, or a transfer of about 9.2 billion from a sub-account holding -2,156, had its trigger at 03:07:10 UTC, when CertiK's records show the recipient at about -9.2 billion. No outside party could see that balance. The trigger came 97 seconds before the 1 USDG withdrawal was applied at 03:08:46, 101 seconds before the first entitlement was published at 03:08:51, and three minutes before the first 500,000 USDG payout at 03:10:15. A second rule, on an account requesting 5.2 million after moving a few dozen USDG through the vault, had its trigger in the same requests. Either one saves money only if it holds withdrawals automatically, because 2,000,001 USDG had left by 03:11:24.
A monitor watching only the chain had a later start. The first payout, 1 USDG, looked like any other withdrawal. The earliest on-chain signal was the vault paying 500,000 USDG to a day-old address at 03:10:15, and the four large payouts landed inside 69 seconds, so no on-chain rule could have stopped the first 2,000,001 USDG. Wired to a pause, it could have covered the 234,390 USDG paid after 03:15.
The vault paid what it was told, so an audit scoped to the BridgeVault would not have reached the bug. The flaw sat in the exchange's own transfer handling, which is server-side code, and reviewing it is part of a full-stack security audit, which covers backend and API code alongside the contracts. For a hybrid exchange, that is where we would start: the transfer and withdrawal paths that decide what the vault will pay, tested at the edges of their integer types.
Frequently Asked Questions
Was the Arcus exploit a smart contract hack?
No, not on anything published so far. Arcus places the bug in how the exchange handled transfers between a user's own sub-accounts, and the BridgeVault paid entitlements that came through the normal publication path. CertiK found the signed 64-bit wraparound in the account records but says which component did the wrapping is unresolved.
How much did Arcus lose, $2.23 million or $5.23 million?
2,234,391 USDG left on-chain. The engine applied 15 withdrawal requests totalling 5,234,391 USDG, but the bridge rate limit held six of them, 3,000,000 USDG, which were never paid and were later reversed. CertiK stresses that the token quantity is not an independently valued dollar loss or attacker profit.
Did Arcus users lose money?
No, according to Arcus, which says no user balances were affected and the shortfall was covered from the Arcus Labs treasury. CertiK says the treasury replenishment has not been independently established.
Has the attacker returned the funds?
No return has been reported as of November 18, 2026. A message described as coming from Arcus offered to let the exploiter keep 10%, about $223,000, if the rest came back by 01:00 UTC on November 13, and its authorship is unconfirmed. The exploiter's Ethereum address now holds 0.00002 ETH, and we have not traced where its ETH went.
Sources / References
- Arcus: Arcus Incident Report: November 9, 2026
- CertiK: Arcus Incident Analysis
- Arcus Status: Perps withdrawals are paused
- Arcus Docs: Architecture
- Arcus Docs: Get account transfer updates
- arcus-xyz/da-reader: src/transfers.ts
- BlockintAI: Arcus Perps Exploit on Robinhood Chain
- PublicAML: Arcus exploit: $2.23M left Robinhood Chain before the block, almost all still with the attacker
- The Crypto Times: Robinhood Chain DEX Arcus Loses $2.23M to Accounting Bug
- Cointelegraph: Robinhood links with dYdX Labs to launch new DEX Arcus
- Etherscan: Arcus exploiter address 0xeFbf442599310E5CeE1A4EDd5c66334c5f30b3Dd
- PeckShield: New batchOverflow Bug in Multiple ERC20 Smart Contracts (CVE-2018-10299)
- Solidity Docs: Solidity v0.8.0 Breaking Changes
- MITRE CWE-190: Integer Overflow or Wraparound



