Date: June 17, 2026

‍Chain: BNB Chain (BSC)

‍Loss: approximately $377.6K (about 610.555 BNB)

‍Class: unauthorized mint to an AMM pair triggered through a zero-value transfer

Summary

On June 17, 2026, LittleBoyPlus was drained of roughly $377.6K from its LBP/USDT PancakeSwap pair. The attack chained two flaws in the token's own contract. The first let an unapproved call slip through the token's transfer logic. The second let that call mint new LBP straight into the trading pair. Together they let the attacker inflate the pair's LBP balance out of nothing while the pair's stored reserves stayed unchanged, and then trade against that fabricated surplus to pull real USDT out. The whole thing ran inside a single flash-loan-funded transaction, borrowed and repaid in the same breath, and the attacker walked away with about 610.555 BNB. No key was compromised and no governance was abused. At every step the contract permitted an action it should have refused.

Background

An automated market maker like a PancakeSwap pair holds two tokens and tracks a cached reserve for each. Its pricing depends entirely on one assumption: the real token balance in the pair matches the reserve it has recorded. When the two agree, swaps price correctly. When they diverge, the price the pair quotes stops reflecting reality, and anyone who can create that divergence can trade against a price that is wrong in their favor.

Two ordinary safeguards are supposed to keep that from happening. ERC-20 allowances mean no contract can move tokens out of an address it hasn't been approved by. And minting is supposed to be a controlled operation, not something an arbitrary caller can trigger against a third party. LittleBoyPlus's token logic broke both, and it broke them in a way that fed directly into the pair's accounting.

Root Cause

The flaw lived in LBPHashrate, and it was really two defects that combined.

The first is an allowance bypass on zero-value transfers. LBPHashrate runs an _update() hook on transfers, and a zero-value transferFrom slips past the ERC-20 allowance check. So a call like transferFrom(pair, DEAD, 0) executes without the pair ever having approved the caller. A transfer of zero moves no tokens, which is exactly why the allowance check let it through, but the call still runs the hook, and the hook is where the damage happens.

The second is an unauthorized mint into the pair. That unapproved zero-value transfer triggers _harvest(pair), which mints fresh LBP directly to the PancakePair through LBP.mintReward(pair, reward). So an arbitrary caller, using a transfer they were never approved to make, causes new tokens to be minted into the trading pair.

The two combine into a reserve break. The minted LBP raises the pair's real LBP balance, but it does nothing to the pair's stored reserve, so balance and reserve diverge. With the pair now holding more LBP than it thinks it does, the attacker calls swap() and extracts real USDT against the fabricated surplus. Neither defect is a stolen key or a governance action. Both are the contract allowing something it should have refused: a transfer without approval, and a mint without authority, wired together so the first triggers the second.

Attack Flow

1. The attacker deployed an orchestrator contract and funded the operation with flash loans, roughly $7.76M in USDT from Lista DAO and about $34M from PancakeSwap Infinity, all to be repaid in the same transaction.
2. The orchestrator called transferFrom(pair, DEAD, 0) on LBPHashrate. Because the transfer moved zero tokens, it bypassed the allowance check and executed without the pair's approval.
3. That call triggered _harvest(pair), which minted fresh LBP directly into the PancakeSwap pair, raising the pair's real LBP balance while its stored reserve stayed unchanged.
4. With the pair's balance now exceeding its recorded reserve, the attacker called swap() to trade against the fabricated surplus and pull real USDT out of the pair.
5. The flash loans were repaid within the same transaction, and the attacker kept the extracted value, about 610.555 BNB, roughly $377.6K.

Impact

The pair's real USDT was extracted to the attacker, backed by LBP that had been minted from nothing. The loss was about 610.555 BNB, roughly $377.6K at the time. Because the drain flowed through the token's own hook and a legitimate-looking swap, nothing about the individual calls looked like theft. A zero-value transfer looks like a no-op, a mint looks like a reward, and a swap looks like trading. The exploit was the sequence, and each piece of it was the contract doing what its code allowed.

The Problem With Audit-Only Security

This exploit is a case where every individual action is permitted and the vulnerability is the combination. That is the hardest shape for a point-in-time review to catch, because reading the code function by function shows nothing obviously wrong.

A reviewer looking at the transfer logic sees a hook that runs on transfers, which is common. A reviewer looking at the harvest path sees a mint that pays a reward, which is intended behavior. The zero-value case that lets an unapproved caller reach the hook is a corner of the transfer logic, and the fact that reaching the hook lets an arbitrary party mint into a third-party pair is a consequence that only appears when you connect the transfer path, the harvest path, and the pair's accounting together. Each is defensible alone. The danger is in the wiring between them, and reviewing one function at a time is exactly the method least likely to surface wiring.

Scope makes it worse. The loss doesn't materialize in the token contract at all. It materializes in the pair, when the minted balance breaks the reserve assumption and a swap prices against it. An audit bounded to the token sees a questionable mint and might rate it low, because in isolation minting a reward looks harmless. The reason it isn't harmless is what it does to a separate contract's pricing, and a review that examines the token without the pair never reaches that conclusion. The exploitable condition lives across the boundary between two contracts, which single-scope review is structurally unequipped to test.

How Olympix Would Have Prevented It

The reason this exploit is catchable before deployment is that it violates properties that can be stated precisely and tested across contracts. A transfer moving zero tokens must still respect authorization. A mint must not be reachable by an unapproved caller. And a token action must never let an AMM pair's real balance diverge from its stored reserve in a way that a swap can extract. Each of those is an invariant, and each one fails on LBPHashrate.

Olympix analyzes a token together with the contracts it interacts with rather than in isolation, which is the only level at which this defect is visible. Its cluster-stage analysis takes LBPHashrate and the PancakeSwap pair as the connected system they form on-chain, follows the zero-value transfer into the hook, follows the hook into the mint, and follows the mint into the pair's reserves. At that level, the unapproved trigger and the reserve break aren't separate curiosities, they're a single path from a zero-value call to an extractable surplus. BugPOCer closes it by building that path into a proof-of-concept: it calls the zero-value transferFrom, shows the unauthorized mint landing in the pair, and shows the swap draining USDT against the fabricated balance.

The proof-of-concept is what makes a combination bug undeniable. Any one of the three findings, a zero-value allowance bypass, a reachable mint, an unguarded reserve, is easy to rank as low or informational on its own, because on its own none of them loses money. A single transaction that chains them and empties the pair removes the option of ranking it low. The team doesn't have to assemble the combination in their head, because the exploit assembles it for them, before the token ever trades.

This isn't an argument against audits. A thorough reviewer may trace the wiring and catch it. It's an argument that an audit alone isn't a security model, because a bug built from three individually-benign pieces across two contracts depends on the reviewer connecting all three, and whether that happens shouldn't be left to chance. Continuous, cross-contract analysis that tests the invariants and proves the chain with an exploit is what turns a lucky catch into a reliable one.

Takeaway

No single call in this attack looked like theft. A zero-value transfer is a no-op, a harvest is a reward, a swap is a trade, and stitched together they minted LBP from nothing into a pair and drained its USDT for about $377.6K. The vulnerability wasn't any one of those actions, it was that the contract allowed an unapproved caller to trigger a mint that broke a separate pair's accounting, a chain that only shows up when you test the token against the market it trades in. Verifying what a contract permits across the contracts it touches, and proving the full chain before it ships, is the difference between a token that stays inside its own boundaries and one that can quietly rewrite a pool's balance. You can see Olympix analyze your token alongside the contracts it interacts with, and prove a chain like this against your own code, with a working proof-of-concept for every finding, in a free demo.

On-Chain References

Protocol:                LittleBoyPlus (LBP)
Chain:                    BNB Chain (BSC)
Date:                     June 17, 2026
Loss:                     ~610.555 BNB (~$377.6K at exploit time)
Vulnerable contract:      LBPHashrate  0x5e3cbc82d020be91a989eb747934104e9ab585fe
Victim pair (LBP/USDT):   0x00e3ea08fd8cbad955ec5d2292ad637670c31524
Attacker EOA:             0xb26DFE6b6180A30e2A2D9826867cc7e06631825a
Attacker orchestrator:    0x5449ded887576f43fc339851e942ebc1e6f8118b (created in the exploit tx)
Exploit tx:               0x55856d9fda4c5be5193561c7d775e823c3d6e499da44aab9da963daf61c50b0c
Flash loans:              ~$7.76M USDT (Lista DAO) + ~$34M (PancakeSwap Infinity), repaid in-tx
Flaw:                     zero-value transferFrom bypasses the allowance check and triggers
                         _harvest(pair) -> mintReward, minting LBP into the pair; the pair's
                         balance diverges from its reserve, and swap() extracts USDT against it


This drain chained a zero-value allowance bypass, an unauthorized mint, and a broken pair reserve, and cross-contract analysis catches and proves that chain before deployment. If you're shipping a token that touches an AMM, see the same analysis run against your own contracts, with a proof-of-concept for the findings that carry real loss. Book a free demo.