A 10-Year Integer Overflow in XRP's Payment Engine: Two Defenses Fell to One Flaw

In early 2025, a security team called Veria Labs pointed an AI agent at the XRP Ledger's payment engine and let it read. The agent came back with an integer overflow. This is not a novel class of bug. It is the same arithmetic failure that let an attacker mint 184 billion Bitcoin in 2010, the same flaw that gutted the BEC token in 2018. What matters is not the category. It is the location. The overflow lived inside the code path that enforces XRP's 100 billion supply cap. Triggered, a single transaction could have generated more than 100 billion XRP in one ledger close — the entire supply, doubled, at once. The minted tokens would have transferred normally. No flag would have fired. No balance would have looked wrong to a casual observer. Just a number that no longer held. I count the cracks before the dam breaks. This one was roughly ten years old. The XRP Ledger has run since 2012. It is a payment and settlement layer, an L1 with a built-in order book DEX, maintained by RippleX and secured by a validator network. XRP is a utility token, not a governance token, not a staking asset. There is no yield, no emission schedule, no inflationary tail. The supply is hard-capped at 100 billion and has been since genesis. That cap is the trust anchor. When a bank or a payment provider treats XRP as a bridge asset, it is trusting that the ledger cannot dilute it. Everything downstream — the ODL corridors, the exchange listings, the custody integrations — rests on that single invariant. That is why the location of the bug matters more than its age. The vulnerability was not sitting in a dormant contract or an unused feature. It sat in the payment engine, the module that handles order aggregation and settlement on the built-in DEX. This is the busiest path on the network. It is also the path that touches supply accounting. To understand why it survived, you have to understand how the ledger is supposed to defend itself. XRPL carried two independent checks. The business layer inspected order aggregation for overflow before a transaction settled. The network layer enforced supply conservation, an anti-inflation check meant to catch any minted value. Two layers, two chances to stop a single bad number. But both layers shared the same arithmetic logic. Same routine, same boundary condition, same blind spot. When the attacker's crafted input crossed the threshold, both checks failed in the same instant. This is not one guard sleeping. It is two guards wearing the same prescription glasses. The bug lived roughly a decade. XRPL is open source. It has been audited more than once. It ran live through multiple market cycles. Ten years of survival is not proof of safety. It is proof that human review has a systematic blind spot for boundary conditions reached only through combined paths. A single function looks fine. The flaw appears only when order aggregation and supply conservation are exercised in the same transaction, with values tuned to overflow both at once. Reviewers read functions. Attackers read paths. The parallel to Bitcoin 2010 is exact and instructive. In August 2010, block 74638 contained a transaction that created 184,467,440,737.09551616 BTC out of an overflow in the value-summing logic. Satoshi had to push a hard fork within hours to erase it. The code was young then. XRPL's flaw is the same arithmetic, in a chain that is thirteen years old and considers itself mature. Age is not a substitute for adversarial testing. If anything, age breeds complacency — the assumption that ten years of eyes means ten years of coverage. The disclosure itself is a clean process story. Veria Labs reported through XRPL's official bug bounty, and RippleX paid the top tier, roughly $250,000. White hats reported, the patch shipped, no funds moved. That loop worked. It is worth stating plainly, because most chains do not have a functioning one. The problem is not the response. The problem is the ten years that preceded it. To trigger the XRPL bug, an attacker needed to set up hundreds of order accounts, construct a specific special order, and submit a dedicated transaction. This is not accidental. You cannot stumble into it. That difficulty is real, and it is the reason the vulnerability was never exploited. But hard to trigger is not safe. For a nation-state actor or a well-capitalized adversary, the cost of opening hundreds of accounts and paying fees is noise. The disclosure notes the attacker would have paid only minimal fees. Against a nominal prize of more than 100 billion XRP, account setup and transaction costs are rounding errors. When I audited ERC-20 fundraising logic in 2017, I learned the same lesson: the barrier to a bug is economic, not moral. If the payout dwarfs the setup cost, the barrier is decorative. Run the number. 100 billion XRP at a modest $2 is roughly $200 billion in nominal value. Even if an attacker could only monetize 1% of it, that is $2 billion of real tokens hitting order books that clear a fraction of that in a day. Liquidity is just borrowed time with a premium. A dump of that size would not find a bid. It would find a cliff. The first casualty would not be the attacker. It would be every holder whose collateral assumed the cap held, every exchange whose reserves were priced against it, every ODL corridor whose settlement treated XRP as a stable bridge. In 2020, I ran arbitrage across Uniswap and Sushiswap and watched liquidity pools buckle under load that was a rounding error compared to this. The mechanical fragility is the same. AMMs and order books do not fail gracefully. They fail at the seam. That is the real subject here. The XRP supply cap is not a policy. It is an arithmetic guarantee, and arithmetic guarantees fail at the edges. The edge here was an overflow, guarded by two checks that were really one check wearing two badges. When I shorted LUNA/UST in 2022, I did not trade sentiment. I traded a broken invariant — a mechanism that could not hold under its own math. This is the same shape, one layer down. The difference is that LUNA's flaw fired. XRP's was caught. Now the governance fracture, which is the part the price ignored. XRPL's normal amendment process requires 80% validator approval sustained over two weeks. That is slow by design. It is the mechanism that makes the decentralization claim more than marketing. For this fix, RippleX did not wait. The emergency patch bypassed the validator vote and went live immediately. From a security standpoint, this was defensible. A two-week window with a live supply-inflation bug is two weeks of open hunting season. But from a governance standpoint, it establishes a fact that cannot be un-established: the core development team can push a consensus-layer change unilaterally when it decides the situation warrants it. Code is law until the miners decide otherwise. Here, the core team decided otherwise, and the validators were informed. I am not calling that wrong. I am calling it a data point. The same capacity that let RippleX patch a bug in hours could, in a different scenario, alter rules in hours. For a chain whose institutional pitch is credible neutrality, the emergency override is a crack in the narrative. It also matters for a different reason. In any securities analysis, the reliance on the efforts of others prong weighs the actual control a core team holds over a network. A team that can bypass validator governance to change consensus rules is a team that still steers the ship. That is a regulatory signal, not just a philosophical one. There is a second-order risk the disclosure did not resolve. If order aggregation and the anti-inflation check shared one flawed arithmetic pattern, what else shares it? AMM pool math. Balance accumulation. Any module that sums large values and compares against a cap. The report says the same root cause defeated both defenses. It does not say the root cause was isolated to those two functions. This is the one technical thread that could produce a second incident. Until a systematic audit of every large-accumulation path is published, the residual risk stays open. I do not take an audit's word for scope. I read the commit. I look for the test that proves the boundary is now checked. Audit scope is the most over-claimed word in this industry. I want the commit hash, not the press release. The contrarian read is this. The market treated the event as a non-event because the bug was never exploited and the fix shipped. Risk is not a number; it is a feeling you ignore. The price barely moved, which is rational for a realized loss of zero. But the information content is not zero. XRP's entire valuation premium rests on supply integrity. A latent, decade-old flaw in the exact module that enforces supply integrity is a stress test that nearly failed, and the market priced it as a footnote. The trust premium should have taken a small, permanent haircut. It did not. That gap between the mechanical reality and the market's calm is where I pay attention. The AI angle compounds it. Veria Labs found this with AI agents, and the disclosure arrived through the official bug bounty, paying the top tier of roughly $250,000. A healthy white-hat loop — better than most chains manage. But the same tool runs in both directions. If a defensive agent can read ten years of code and find an overflow in the payment engine, an offensive agent can read the same code and find the next one first. This is a speed race now. Defense found this one. That is a sample of one. It is not a lead. I built an AI options agent in 2025 precisely because I do not trust black boxes I did not code. The same skepticism applies here. An AI that finds bugs is a tool. It is not a guarantee. There is also a competitive shadow. Stellar, born in the same 2014-2015 window with a structurally similar payment design, inherits the same class of risk by lineage. When one payment chain discloses a ten-year arithmetic flaw in its settlement engine, every chain with shared ancestry should be re-reading its own accumulation paths. Sector-level disclosure risk is real. A single confirmed exploitation elsewhere would reprice the whole payment-L1 basket, XRP included, regardless of its own clean fix. What I watch from here is narrow and mechanical. First, whether a third-party audit confirms the same arithmetic pattern does not reappear in AMM and balance-calculation modules. Second, the validator upgrade rate after the emergency patch, because a version split is a window where old nodes accept and new nodes reject — a consensus inconsistency with its own price. Third, whether the emergency-override precedent is formalized or quietly forgotten, because the answer tells you how decentralized this network really is when it matters. The bug is dead. The question it leaves is not about one overflow. It is about whether a chain that can be patched by a handful of people in hours, and that nearly printed its own supply cap in a single transaction, deserves the neutrality premium it charges. Survival is the only alpha that compounds. But survival is not the same as safety, and the market is pricing the two as if they were.