An integer overflow vulnerability in the XRP Ledger's payment engine, introduced in 2015 and undetected for 11 years, could have allowed an attacker to mint up to 18.45 trillion XRP in a single transaction — 184 times the token's hard-capped 100 billion supply. At current prices ($1.42 per XRP), ...
"Things have changed with AI. You can't just sneak in a critical bug patch in a regular public release process, because you're going to get caught and reverse engineered right away." — Mayukha Vadari, Engineer, RippleX
An integer overflow vulnerability in the XRP Ledger's payment engine, introduced in 2015 and undetected for 11 years, could have allowed an attacker to mint up to 18.45 trillion XRP in a single transaction — 184 times the token's hard-capped 100 billion supply. At current prices ($1.42 per XRP), that represents approximately $26.2 trillion in counterfeit tokens against a legitimate market capitalization of $89.5 billion.
The flaw was discovered on September 21, 2026, by Veria AI, an artificial intelligence security agent operated by Veria Labs. The firm received the XRPL Bug Bounty Program's maximum payout of $250,000 — reportedly the largest bounty ever paid for a vulnerability discovered entirely by an AI agent. RippleX shipped a patch (xrpld 3.4.1) three days later on September 25, but withheld the source code for approximately two weeks to prevent reverse engineering. The corrected amendment activated on mainnet on October 9, 2026, and full disclosure followed the same day.
No evidence of exploitation was found on any public network. The incident nevertheless raises three structural questions: how a safety-critical invariant check failed alongside the bug it was designed to catch, whether AI-driven security research is now faster than traditional auditing, and what open-source blockchain governance looks like when emergency patches cannot be publicly reviewed before deployment.
The XRP Ledger stores token balances as fixed-size integers with a defined maximum value. When the payment engine processes a transaction that consumes multiple offers from the order book, it sums the amounts paid to each offer owner. The code performed no overflow check on this sum.
The exploit path was as follows: an attacker could open hundreds of accounts, each placing a small token offer in exchange for an enormous quantity of XRP. A single crafted payment would then consume all offers simultaneously. The engine would pay each seller their full amount individually. But when calculating the total charged to the buyer, the sum of all payments would exceed the integer maximum and wrap around to a small number — potentially just a few hundred drops (the smallest XRP unit) plus the transaction fee.
The difference between what sellers received and what the buyer paid was new XRP that should never have existed. This XRP would be fully spendable, indistinguishable from legitimate tokens on the ledger. According to RippleX's disclosure report, exploitation required constructing hundreds of malicious orders, costing approximately hundreds of XRP in reserves and fees — a trivial barrier relative to the trillions of XRP that could be minted.
The bug was introduced when the current payment engine was written in 2015. All versions of xrpld through 3.4.0 were affected.
The XRP Ledger includes a built-in invariant checker — a secondary validation layer designed to confirm that no transaction creates new XRP. This check is the protocol's final line of defense against supply inflation, a critical guarantee for a token whose entire monetary policy rests on the premise that 100 billion XRP were created once, in the genesis ledger of 2012, and no more can ever be produced.
The invariant checker failed because it summed balance changes using the same arithmetic that the payment engine used. When the payment engine's sum wrapped around due to overflow, the invariant checker's sum wrapped around identically. The check passed. No alert was raised.
This is a textbook example of correlated failure: the safety mechanism shared the same flaw as the system it monitored. The XRP Ledger's architecture assumed that if the payment engine produced a result, the invariant checker would independently verify it. In practice, both systems used the same mathematical operation, meaning one bug neutralized both layers simultaneously.
The fix in xrpld 3.4.1 adds explicit overflow detection. If the sum of offer amounts would exceed the integer maximum, the transaction now fails cleanly rather than wrapping around.
Veria Labs, an AI security startup, identified the vulnerability on September 21, 2026, using an AI agent pointed at the rippled codebase. According to Veria Labs co-founder Cayden Liao, the AI agent independently discovered both the overflow bug and the invariant checker failure, determined how to chain them together, and constructed a working exploit on a local test network to prove the vulnerability.
Veria filed the bug report through the XRPL Bug Bounty Program the following day, September 22. The $250,000 bounty — the program's maximum — was subsequently awarded.
The discovery is notable for two reasons. First, the bug had been present for 11 years across a codebase that has been reviewed by human auditors, operated by approximately 35 default UNL validators, and processed over 70 million ledger closes. Second, the vulnerability required chaining two individually low-severity bugs — the overflow itself and the invariant checker flaw — into a critical exploit. Veria suggested that this chaining requirement is one reason human reviewers did not catch it: each component appeared benign in isolation.
The XRPL Bug Bounty Program, administered through Immunefi, had previously paid smaller amounts for lower-severity findings. The $250,000 payout is substantial but modest compared to the broader Web3 bounty landscape, where Wormhole paid $10 million in 2022 for a bridge vulnerability and programs from Uniswap ($15.5 million) and Usual ($16 million) have set higher ceilings for critical findings. In the context of AI-discovered bugs specifically, however, the Veria payout appears to be the largest confirmed bounty for a vulnerability found entirely by an autonomous AI agent.
RippleX shipped the patch in xrpld 3.4.1 on September 25, 2026 — three days after receiving the bug report. The binaries were distributed to validators, but the source code was withheld for approximately two weeks.
This decision was deliberate. Because xrpld is open-source software, a standard release would have included the source code diff, revealing the exact location and nature of the vulnerability. Attackers could potentially reverse-engineer the bug and construct an exploit before a supermajority of validators upgraded. RippleX chose to distribute the fix as compiled binaries first, allowing validators to upgrade without publicly disclosing the vulnerability.
The approach marks the first time the XRPL development team bypassed the normal amendment process — the on-chain governance mechanism through which protocol changes are proposed, voted on by validators, and activated — for a security patch.
The decision drew criticism from parts of the XRP community and the broader open-source ecosystem. Critics argued that distributing closed-source binaries for a supposedly open-source protocol undermines the trust assumptions that validators and users rely on. If validators cannot review the code they are running, the argument goes, the network's decentralization guarantees are weakened.
RippleX engineer Mayukha Vadari addressed this tension directly, noting that the rise of AI changes the calculus around responsible disclosure. In an era where AI agents can analyze code diffs and reconstruct exploits in minutes, the traditional open-source approach to security patching — publish the fix and hope validators upgrade quickly — becomes a potential attack vector in itself.
The corrected amendment gained sufficient validator support and activated on mainnet on October 9, 2026. The full vulnerability disclosure report was published the same day. The source code for the 3.4.1 patch was released approximately two weeks after the initial binary distribution.
The xrpld 3.4.1 release also addressed a second, less severe vulnerability affecting the network's Batch transactions feature. This bug could have caused server divergence — a condition where validators disagree on the current state of the ledger — and halted validation of new ledgers.
Unlike the overflow bug, the Batch transaction flaw was a denial-of-service vector rather than a supply-inflation risk. It was fixed through the fixBatchV1_2 amendment, which activated alongside the overflow patch on October 9.
The economic stakes were substantial in theory but contained in practice:
| Metric | Value | |--------|-------| | XRP market cap at disclosure | $89.5 billion | | XRP price at disclosure | $1.42 | | Maximum mintable XRP (single tx) | 18.45 trillion | | Theoretical value of minted tokens | $26.2 trillion | | Bug present in codebase | 11 years (2015–2026) | | Evidence of exploitation | None found | | Bounty paid | $250,000 | | Time from report to patch | 3 days | | Time from patch to mainnet activation | 14 days |
If exploited, the impact would not have been a $26.2 trillion gain for the attacker. Mass minting would have collapsed XRP's price, likely to near zero, as the market recognized that the supply cap — the fundamental scarcity guarantee — had been violated. The real risk was existential: permanent destruction of confidence in the XRP Ledger's monetary integrity.
XRP traded at approximately $1.39–$1.42 in the days following the October 9 disclosure. The limited price impact suggests the market accepted that the vulnerability was patched before exploitation and that no supply integrity breach occurred.
The Veria Labs discovery lands in a rapidly expanding field. AI-powered smart contract and protocol auditing tools have proliferated in 2026:
Immunefi, the dominant Web3 bug bounty platform, has paid $134 million cumulatively to ethical hackers through Q1 2026 across 230 active programs protecting more than $190 billion in total value locked. The platform's data shows Web3 security spending growing, but the Veria discovery illustrates a gap: AI agents may now find bugs faster than human researchers and faster than the protocols can safely patch them.
This creates a dual-use problem. The same AI that Veria Labs used to find the XRP overflow bug could, in a different set of hands, be used to find and exploit similar bugs before they are reported. Vadari's warning — that AI makes stealth patching impractical in open-source codebases — cuts both ways. It also means open-source protocols may face a narrowing window between vulnerability discovery and exploitation.
An 11-year-old integer overflow bug in the XRP Ledger could have minted 18.45 trillion XRP — 184x the fixed supply — in a single transaction. The built-in invariant checker designed to prevent exactly this scenario failed due to shared arithmetic.
An AI agent discovered the vulnerability. Veria Labs' autonomous agent found the bug, chained it with a second flaw, and built a working exploit on a test network. The $250,000 bounty is the largest confirmed payout for an AI-discovered vulnerability.
RippleX shipped the fix in closed-source binaries, withholding the source code for two weeks to prevent reverse engineering. This is the first time the XRPL amendment process was bypassed for a security patch.
No exploitation occurred. Developers found no evidence the bug was used on any public network during its 11-year window of exposure.
The incident exposes a growing tension between open-source transparency and the speed of AI-driven security research. Protocols that publish code changes immediately may be giving AI-armed attackers a head start.
The XRP Ledger overflow bug represents one of the most severe theoretical vulnerabilities in the history of a top-five cryptocurrency by market capitalization. Its discovery and resolution demonstrate both the promise and the peril of AI in blockchain security.
On one hand, an AI agent accomplished what 11 years of human code review, validator oversight, and formal invariant checking did not: it found the bug, understood its implications, and proved it could be exploited. On the other hand, the same capability that made Veria's agent effective makes responsible disclosure harder. When AI can reverse-engineer a code diff in minutes, the traditional open-source patch cycle becomes a race against autonomous adversaries.
For the XRP Ledger specifically, the incident raises questions about the robustness of the invariant checker architecture — a system that shared the same flaw as the mechanism it was designed to monitor — and about the governance implications of closed-source emergency patches on an ostensibly open-source network.
For the broader blockchain ecosystem, the message is simpler: the bar for security auditing has shifted. AI agents are now finding critical bugs in production codebases that human reviewers have examined for over a decade. Protocols that are not incorporating AI into their security review processes — or that are not preparing for the possibility that adversaries will — are operating on assumptions that may already be obsolete.