A Balance on Screen Isn't Proof of Funds: How Arcus Lost $2.23 Million

Arcus lost 2.23 million USDG after an accounting bug inflated a user's balance. Here's how it happened and why a withdrawal limit prevented further losses.

Share
A glowing orange asset appears duplicated across two transparent containers connected by a metallic channel.

An accounting bug, not a reported private-key compromise, let a new Arcus account withdraw funds it didn't actually hold. The incident is a useful lesson in the limits of balances, transaction validity, and automated withdrawal controls.

How can someone withdraw money they don't have?

Imagine a bank account with $100. You move $40 from the main account to a savings subaccount. After the transfer, the main account should show $60 and the savings account $40. The total is still $100.

Now imagine the system credits the savings account with $40 but fails to reduce the main account. Its records say you have $140, even though only $100 exists.

This is an illustration, not a reconstruction of the exact Arcus bug. The company has not published the specific triggering conditions or code path. But it captures the essential failure: an internal balance can stop representing the assets actually available. If withdrawals rely on that mistaken figure, the error becomes more than a display problem.

What happened at Arcus?

At approximately 03:07 UTC on November 10, 2026 (10:07 p.m. Eastern on November 9), an attacker exploited an accounting flaw at Arcus, a decentralized trading platform. According to Arcus's incident report, a newly created account used transfers between its own subaccounts to produce a recorded balance substantially larger than its real holdings.

The account then requested withdrawals against the inflated balance. The result was a completed on-chain withdrawal of 2,234,391 USDG, a dollar-denominated stablecoin. A further roughly $3 million in withdrawal requests was caught by the bridge's rate limit and subsequently reversed. That additional amount was never paid out, so it should not be added to the realized loss.

Actually withdrawn: 2,234,391 USDG

Further requests blocked: approximately $3 million

The underlying mechanism and the distinction between paid and blocked withdrawals are also documented in an independent incident advisory. No evidence in these disclosures establishes a stolen private key as the cause.

Where did the system go wrong?

A DeFi trading platform can represent the same assets at several different layers. Each layer answers a different question:

  • On-chain assets. Which tokens are actually held by addresses, bridges, or smart contracts?
  • Internal account balances. How much does the protocol record as belonging to a particular user or subaccount?
  • Withdrawable funds. How much will the platform allow that account to move out, after applying its rules and constraints?

These figures are related, but they are not interchangeable. Open positions, collateral requirements, pending transfers, and withdrawal restrictions can all change the amount a user is entitled to withdraw.

One invariant should remain true for an ordinary transfer between a user's own subaccounts: moving funds internally must not increase the total amount owned by that user. Arcus says the accounting of such transfers was flawed, allowing an account to request funds beyond its actual balance.

The public report does not identify the exact operation that incorrectly updated the records, so claims such as 'the system forgot to debit the sending subaccount' would go beyond the evidence. The defensible conclusion is simpler: a withdrawal mechanism can execute a perfectly real transaction based on an incorrect accounting state. The chain records that assets moved; it cannot by itself verify that the platform calculated the user's entitlement correctly.

Why did the withdrawal limit matter more than response speed?

Arcus's published incident timeline, converted to UTC, shows two different kinds of defense at work:

November 10
  1. Attack

    Exploit activity begins.

  2. Attack

    The bridge rate limit caps payouts, holding back about $3 million in additional requests.

    +3 min
  3. Response

    Monitoring flags the suspicious withdrawals and the team begins investigating.

    +8 min
  4. Response

    Platform-wide withdrawals are paused.

    +1 h
  5. Response

    The accounting fix is deployed.

    +1 h 30 min
  6. Resolved

    Withdrawals reopen.

    +6 h 19 min
  7. Resolved

    Arcus Labs covers the shortfall from its company treasury.

    +14 h 21 min

The sequence matters. Monitoring caught unusual activity, and the team investigated and deployed a fix. But by then more than $2.23 million had already left. The bridge limit had acted earlier, without waiting for a person to identify the bug.

Monitoring and incident response help a team notice a problem and intervene after suspicious behavior begins. A withdrawal rate limit places a predefined ceiling on how much value can leave over a given interval. These controls solve different problems.

A rate limit does not repair flawed accounting or guarantee safety: attackers can still extract substantial assets before it activates. In this incident, however, it contained further damage. Good system design has to consider not only how to prevent failure, but also how far one failure is allowed to spread. The detailed timeline is independently reproduced in The Crypto Times coverage.

If user funds weren't affected, is that a happy ending?

Arcus said that the exploit involved one account and did not affect other users' balances, positions, or orders. The company also stated that it covered the full 2,234,391 USDG shortfall from the Arcus Labs treasury.

That outcome is important, but two terms should not be confused:

  • Covering a shortfall means replacing the missing value with funds from elsewhere, such as a company's own reserves.
  • Recovering stolen assets means the assets transferred out during the exploit are actually returned or seized and restored.

Covering a shortfall is not the same thing as recovering the original withdrawal. In its report, Arcus said it was tracking the withdrawn funds. An on-chain review published November 11 traced subsequent transfers but did not establish their recovery. The available findings therefore support a distinction: Arcus says it made the protocol whole; they do not prove the attacker returned the assets.

For users, the company's reported outcome was reassuring. But it depended on Arcus choosing to deploy its own capital. That should not be mistaken for a guarantee that another protocol would, or could, do the same.

How can DeFi users reduce this kind of risk?

Most people cannot personally audit every line of protocol code. They can, however, get more precise about the risks they accept.

  • Treat audits as evidence, not a warranty. Check which contract versions and components were reviewed, whether meaningful changes followed, and whether the platform has disclosed unresolved issues.
  • Look for damage-limiting controls. Withdrawal rate limits, anomaly detection, emergency pauses, and transparent incident procedures can matter as much as prevention. Also ask who can operate these controls and what new trust assumptions that creates.
  • Avoid concentrating more funds than necessary in one protocol. Assets exposed to a trading platform are subject to its accounting, contract, operational, and governance risks even if your own key management is sound.
  • Separate active trading from long-term holdings. Funds that do not need to participate in a protocol should not automatically share its exposure to failures.

The practical question is not only whether an interface displays your balance, but where the assets actually sit and which systems must work correctly for you to get them back.

The real lesson from Arcus

In crypto, 'don't trust, verify' is often discussed in terms of addresses, private keys, and transaction signatures. The Arcus incident points to another layer: the financial logic deciding whether a withdrawal is justified.

A balance can look legitimate. A withdrawal can be correctly formatted. A blockchain can process it exactly as instructed. The payout may still be unauthorized because the accounting was wrong before the transaction reached the chain.

A blockchain can confirm that funds moved. It does not automatically prove that the account had the right to withdraw them. This is why security is not one perfect check, but multiple independent controls with different failure boundaries.

A related distinction appears in our analysis of the Ankr bridge exploit, where cryptographically valid approvals did not prove that the events described by those approvals had happened.

CTA Image

Secure signing is one layer of the picture. See what the ERA Wallet device helps you verify before approval. Code ERABLOG20 for 20% off.

Explore ERA Wallet