On July 21 and 22, 2026, Balance Coin (BLC), the dollar stablecoin of the BNB Chain protocol 42DAO, fell from its dollar peg to a fraction of a cent and stayed there. The protocol is a fork of MakerDAO's collateral engine, and the failure is one of the cleanest teaching cases we have seen this year, because the fork copied the machine that mints a stablecoin against collateral and left out the one part of Maker's design that exists specifically to stop what happened next. Security firms put the extracted value at roughly 912,000 to 915,000 dollars. That figure is real, but it is not the number that tells the story. The number that tells the story is on the token itself.
We recomputed the whole incident from the chain before writing a word, which is our standing practice on these teardowns and, in this case, changed one of the widely repeated facts. Everything below is read directly from BNB Chain state: raw supply calls, the token's mint and burn log, and a decoded trace of the attack transaction, cross-checked against independent archive nodes. Where we cite a figure we did not derive ourselves, we say so and name the source.
The one number that tells the story
BLC's total supply went from about 404,760 tokens on the morning of July 21 to 9,910,949 tokens by the morning of July 22, and it has not moved since. That is a twenty-four-fold inflation of a dollar stablecoin in roughly twelve hours. We read it three ways to be sure: the token's current totalSupply returns 9,910,949.93 BLC identically across five independent BNB Chain endpoints, the same call against archive state a day earlier returns 404,760, and a full scan of every mint event (a transfer out of the zero address) over the window accounts for the difference to the token. Nothing about that supply is disputed and nothing about it requires trusting a dashboard. It is the plainest possible statement of what an unbacked mint looks like: twenty-four times as many tokens outstanding, against the same collateral that backed the float the day before.
The peg followed the supply. In the PancakeSwap pool that holds almost all of BLC's liquidity, the reserves one block before the attack were 53,534 BLC against 53,464 dollars of Binance-pegged USDT, a price of 0.9987, a coin sitting on its peg. One transaction later the same pool held 4,554,531 BLC against 630 dollars, a price of 0.000138. The pool was drained of its dollars and buried in freshly minted BLC in a single block. It has never recovered; as of this writing it holds about 1.25 million BLC against 2,400 dollars, and BLC trades near 0.0019.
What the transaction actually did
Because 42DAO is a Maker fork, its parts carry Maker's names, and reading the attack transaction is a matter of following those parts in order. We confirmed the fork directly: the BLC token exposes Maker's wards authorization map, and the attack transaction touches a Vat (the central accounting ledger, with Maker's frob, slip and file functions), a Spotter (which reads a price and writes it into the Vat), a price oracle, a collateral join adapter for BTCB, and the join adapter that mints BLC. These are the same five roles that run every Maker vault.
Here is the sequence, decoded from the trace of the primary transaction. The attacker poked the protocol's oracle, then poked the Spotter for the BTCB collateral type. The Spotter read the oracle's price, divided by the collateralization ratio, and wrote the result into the Vat as the new spot price for BTCB. We pulled the exact value it wrote. The oracle reported BTCB at one quadrillion dollars, that is 1,000,000,000,000,000 dollars per coin, and the spot price the Spotter recorded in the Vat was roughly ten billion times BTCB's real value. BTCB was trading at about 66,589 dollars at that block, which we also read from the chain. With BTCB now recorded as worth a quadrillion dollars each, the attacker deposited about 10.7 BTCB and, in the same transaction, drew 4,500,996 BLC of fresh debt against it. The join adapter minted that BLC to the attacker, who sold it into the pool. Then it happened twice more, from two other addresses, over the next twelve hours, including a five-million-BLC mint the following morning that most coverage did not pick up.
One detail here is worth pausing on, because we recompute precisely so we can catch it. The published analyses, including the security firms and the outlets that carried them, describe the manipulated price as abnormally low, feeding forced liquidations of BTCB vaults. On the chain, the transaction they cite does the opposite: the price was pushed abnormally high, and it was used to over-mint, not to liquidate. The proof does not depend on our reading of the fork's internals. Minting almost 4.5 million brand new BLC out of the zero address, which we see plainly in the transfer log, is only possible if the collateral backing it is valued far above its worth; a price pushed down cannot mint anything. We are not writing this to correct anyone. 42DAO's own team has published nothing, and the firms moved fast on a live incident, which is what fast alerts are for. We are writing it because the direction of the manipulation is exactly the kind of fact that gets compressed in the first hours and then repeated, and the only way to know which way it ran is to read the transaction yourself.
The part the fork removed
A quadrillion-dollar price for bitcoin is absurd on its face, and the useful question is not how the attacker produced it but why nothing in the protocol refused it. In Maker's real design, several things would have. The first and most important is the Oracle Security Module, the OSM. Maker does not let a fresh price reach the Spotter directly. It routes every price through a module that holds it for one hour before it becomes usable, and during that hour governance can look at the queued price and cancel it if it is wrong. The delay exists for exactly this attack: a manipulated price is useless if it cannot be acted on until an hour later, in a separate transaction, in full public view.
42DAO's deployment has no such delay, and we can prove it from the transaction rather than infer it. The price poke and the mint that used the price happen in the same transaction, in the same block. That is impossible under an OSM, where the price you poke now cannot be consumed until an hour has passed. The fork copied the Vat, the Spotter, the join adapters and the liquidation module, and wired the Spotter to read a raw price feed with no module in between. It also, by the security firms' account and consistent with what we see, carried no price-deviation check, no floor or ceiling on how far a single update could move, and no delay on liquidation. A one-quadrillion-dollar bitcoin passed straight through into the ledger and was spendable in the same breath. The only limit that bit at all was a debt ceiling of five million BLC per collateral type, which is why the mints came in roughly five-million-token bites rather than as one unbounded draw.
Inherited armor with the rivets pulled out
The lesson generalizes past this one protocol, and it is the reason forks fail in a particular way. When you write a system from scratch, its gaps are visible as gaps; nobody assumes a protection is there until it is built. When you fork a battle-tested system and remove a protection, the removal is invisible. The code still looks like Maker, the functions still carry Maker's names, and anyone who reasons by analogy, this is a Maker fork, so it must behave like Maker, is reasoning about a machine that no longer exists. The OSM is the clearest case because it is not a feature you notice by using the protocol. A vault opens the same, a mint reads the same, a liquidation looks the same. The one-hour delay only shows itself the day someone feeds the oracle a lie, and by then the fork that removed it has already paid for the omission. Inheriting a proven design is not the same as inheriting its safety, and the difference is precisely the parts that do nothing until the worst day.
This is also why the failure was legible in advance to anyone who looked, and why we keep saying that most of these losses are readable before they are exploited. 42DAO's contracts were public and, in the case of the liquidation module, verified on the block explorer. The absence of an OSM in the price path was not hidden; it was a wiring choice sitting in open source, waiting for someone to notice that the Spotter read a raw feed. The attacker was simply the first party with an incentive to check.
Where Kerne stands, and where we do not
We build a dollar too, so the interest is declared, and the honest version of this comparison is narrower than the one you might expect. This is not a case our proof of reserves would have caught that theirs did not, because nothing here was hidden. BLC's whole failure was in plain, public code. The relevant contrast is architectural, and it is about which price a protocol trusts and how fast it can act on a lie.
kUSD, as it is deployed today, is not a Maker-style collateralized debt position. Its live mint path is one to one against USDC through a Peg Stability Module, so there is no oracle-priced collateral to over-value and no liquidation engine to trigger. The category of failure that ended BLC, a manipulated collateral price minting unbacked stablecoin, has no surface to land on in that path, because the mint is not priced by an oracle at all. Where it matters more directly is the discipline the fork skipped: a price is only as trustworthy as the depth behind it. Our own on-chain liquidity is thin, and we do not use it as a price input for anything, precisely because a few hundred dollars of flow through a shallow pool would move it, which is the same class of reasoning that a raw, uncapped feed abandons. The reserve figure a holder checks against us is read from chain state and an hourly signed proof at /verify and /api/por, not inferred from a market price that a small trade can bend.
The boundaries belong in the same paragraph, because a teardown that hid its author's own gaps would be the thing it is criticizing. We are pre-audit: our first external review delivered its initial report on July 20, 2026, remediation is underway, and the final report is pending, so our code is not yet through a completed audit and we say so on every surface. Our reserve book is small, currently a little over a thousand dollars, and it sits first and worst on our honesty index by design. The delta-neutral hedge runs at pilot scale against a small, disclosed, founder-custodied float and is self-reported rather than independently re-derivable on-chain. None of that is a claim to be safer than the protocol above. It is a claim to be legible, which is a different and smaller thing, and the only one we make.
If your public claims outrun your chain
The read we ran on 42DAO, does the deployed code do what the design promises, is the same one we sell as a fixed-scope service: a Disclosure Integrity Audit, 499 dollars, 72 hours, a signed findings summary you can publish, covering whether your public claims match your chain before someone else checks for you. The worked example is free: this teardown, and our scrvUSD projected-versus-realized read.
Sources and reproduction, all as of July 23, 2026. On-chain figures were recomputed first-hand against BNB Chain archive state and are point-in-time. BLC token 0x5343b4586a3f2a3365df92Ee705c3BF446C54668: totalSupply read as 9,910,949.93 across five independent public RPC endpoints, and against archive state one and two days prior returning 404,760; identity confirmed as a MakerDAO Dai fork via the presence of the wards authorization map. The three exploiter mints (4,500,996.40 BLC at 2026-07-21 21:00:01 UTC, 5,889.99 BLC at 23:00, and 5,000,000 BLC at 2026-07-22 09:00:02 UTC) were recovered by scanning transfers from the zero address over the window. The primary transaction 0xe7abe6416e386332b41d63cf5f16903251dc178942cd79bf080fe61058587628 (block 111,351,152) was decoded via debug_traceTransaction: the Spotter at 0x849dc2416cbe54995a1d725afe526c0e38829228 wrote a BTCB spot price into the Vat at 0xfa7cea82f8a6254ccebad71350125aa6171b8a84 derived from an oracle price of 1e33 (one quadrillion dollars per BTCB), against a real BTCB price of about 66,589 dollars read from the PancakeSwap BTCB/USDT pool at the same block; the attacker then drew 4,500,996 BLC of debt against about 10.7 BTCB in the same transaction. PancakeSwap BLC/USDT pool 0x1394938567760162bc604fcca6daed9dbe1433ca reserves read against archive state at blocks 111,351,151 and 111,351,152. Loss figures are attributed, not independently derived: SlowMist reported approximately 912,000 dollars in its threat-intelligence alert and 915,000 dollars in its hacked-incident database; PeckShield reported approximately 915,000 dollars. The characterization of the manipulated price as abnormally low feeding liquidations is the published account across those firms and the outlets carrying them; the on-chain record of the cited transaction shows an abnormally high price used to over-mint, which is the correction noted above. 42DAO had published no statement as of this writing. Kerne figures resolve to live endpoints: reserves at /api/por and the signed proof at /api/por/signed; audit status at /security/audits; the advertised-versus-realized row at honesty index. Nothing here is investment advice, an allegation of wrongdoing by any named firm or individual, or an assertion of a root cause 42DAO has not confirmed. Recompute before relying on any figure here, including ours.
Verify it yourself
Run the same check on any reserve, or have it run for you.
Paste any issuer's signed attestation into the free verify tool and recover the signer, rehash the figures, and check freshness in your own browser. For a machine-signed, point-in-time read of an address you name, delivered on the page in about two minutes, the instant self-serve read is $29; a human-reviewed read is $149. A teardown like this one, commissioned on any target you name, is $499. An independent read of a counterparty you hold or allocate to is $2,500. Attestation tooling, not an audit, and not a solvency opinion.