Cowrie Research

minimum-unit-burn-rounding-and-low-decimal-asset-discipline

13 min read

Minimum-Unit Burn Rounding and Low-Decimal Asset Discipline

  • Name: minimum-unit burn rounding and low-decimal asset discipline

  • Category: solvency-arithmetic reference / quantization-boundary checklist / low-decimal asset design companion / burn-rounding control note

  • Summary: Protocols do not fail only because arithmetic rounds. They fail because a balance-sheet transition that is economically continuous is implemented over discrete token quanta, and the design quietly assumes those quanta are too small to matter. That assumption breaks when unit price or index value becomes extreme, when supply collapses toward dust, or when the asset itself has coarse decimals like WBTC. In those states, ~1.999999 minimum units should burn versus 1 minimum unit actually burns is not a nuisance rounding loss; it is a solvency event. This note exists to preserve the positive-design target behind Hundred, Midas, HopeLend, Radiant, Starlay, ZeroLend, and similar incidents: minimum token unit, burn direction, and quantization edge behavior should be treated as first-class control surfaces anywhere share, receipt-token, or indexed-balance math can become collateral truth.

  • Why this note exists:

    • empty-market-exchange-rate-inflation preserves the Compound-style family where tiny supply plus an inflated exchange rate makes redeemUnderlying or similar paths under-burn shares.
    • supplier-index-inflation preserves the Aave-style family where empty-market index growth and floor-rounded burns let attackers preserve dust positions while cashing out real value.
    • What still deserves a narrower positive-design note is the arithmetic control surface beneath both families: how protocols should reason about minimum units, low-decimal assets, burn direction, and quantized solvency before inflated unit prices can turn a one-unit rounding gap into extractable money.

The core design rule

If one minimum token unit can become system-relevant money, then the protocol must treat quantization boundaries as solvency logic, not as harmless implementation detail.

Healthy systems should be able to answer all of these explicitly:

  • what is the smallest burnable, mintable, or withdrawable unit for this asset or receipt token?
  • what happens when economic reality says burn 1.999999 units but the runtime can only burn whole quanta?
  • which direction does rounding go on each path, and who benefits from that direction under extreme unit-price states?
  • what state transitions are supposed to be impossible before quantization becomes dangerous, and does code actually enforce those assumptions?

What this note means by minimum-unit discipline

  • Minimum unit means the smallest indivisible quantity the runtime can burn, mint, withdraw, redeem, seize, or account for on a given token or receipt-token rail.
  • Low-decimal asset means an asset whose smallest unit is economically coarse relative to protocol TVL or share-price variance; WBTC is the clean recurring example, but the deeper issue is economically meaningful quantum size, not a specific decimal count.
  • Quantization boundary means the point where continuous economic intent is projected onto discrete token units and one unit of rounding starts to matter.
  • Burn rounding includes any redeem, withdraw, liquidation, or debt-share reduction path where floor division, truncation, or minimum-unit clipping can consume less state than economic reality requires.
  • The analytical habit is simple: a protocol should never let the next discrete unit become a privileged solvency object by accident.

Three quantization promotions reviewers should not collapse

  1. Economic reality says the next state transition needs more than one minimum unit
  • The continuous solvency story may require 1.2, 1.99, or N + fractional remainder units of burn, seize, or debt reduction.
  • This is only an economic statement about what should have been consumed, not yet a statement about what the runtime actually published.
  1. The runtime published one discrete state transition by rounding that reality onto minimum units
  • A redeem, withdraw, liquidation, or debt-reduction path chose 1, 2, or some other whole-unit result because the rail cannot consume fractions.
  • This is already a stronger claim than economic entitlement existed: the protocol has now committed to one concrete state transition, but it still has not answered whether that transition is safe to treat as full solvency truth.
  1. Downstream balance-sheet logic spent against that rounded result as if it were economically exact
  • Reserves, sibling markets, collateral engines, liquidation paths, or recursive loops now honor the rounded burn or redemption as if the consumed state and released value still matched.
  • This is the dangerous promotion in the family. Minimum-unit exploits become expensive only when the protocol lets a coarse rounded state transition cash out like an exact one.

The design target is to keep these promotions explicit: economic reality required this much state, the runtime can only consume whole quanta, and the rest of the protocol will or will not treat that coarse result as money-good are different review questions.

The five separations healthy design should preserve

1. Economic value versus token quantum

  • Economic entitlement can vary continuously, but settlement happens in discrete units.
  • Healthy systems keep track of when one quantum is too large relative to the protected value.
  • If a single hToken wei or receipt-token atom can temporarily represent tens of thousands of dollars, the protocol is already in a dangerous arithmetic regime whether or not any exploit path has fired yet.

2. Ordinary rounding versus adversarial state creation

  • Floor rounding is often fine in healthy high-supply states.
  • The danger begins when another design error lets the attacker create a state where the next unit boundary is economically huge: empty markets, inflated exchange rates, pumped liquidityIndex, or coarse-decimal collateral.
  • Healthy review therefore asks not only is rounding conservative? but what upstream state makes this rounding suddenly decisive?

3. Local arithmetic correctness versus solvency safety

  • A formula can be mathematically correct in integer arithmetic and still be unsafe for solvency because it floors in the user’s favor at exactly the states the protocol most needs conservatism.
  • rayDiv, mulDiv, share conversions, and exchange-rate math should be reviewed as policy, not as merely library behavior.
  • The relevant question is not does the code do floor division consistently? but does consistent floor division leak value once unit price becomes extreme?

4. Asset decimals versus receipt-token decimals

  • Many systems normalize around 18-decimal thinking while the underlying asset, the receipt token, and the index math may live on different scales.
  • WBTC-style 8-decimal assets, ERC-4626 shares, cToken-style 8-decimal receipt tokens, and Aave-style scaled-balance math can create quantization cliffs even when individual components look familiar in isolation.
  • Healthy systems model the whole conversion chain end-to-end rather than trusting each hop separately.

5. Impossible state assumptions versus enforced state machines

  • Teams often assume minimum-unit risk is harmless because supply should never get that low, index should never get that high, or one user should never own the denominator.
  • Those are state-machine assumptions, not arithmetic truths.
  • If code does not enforce them, the minimum-unit boundary is live attack surface.

What sound design looks like

1. Solvency-critical burns fail closed near quantum boundaries

  • Redeem, withdraw, liquidation, and debt-reduction paths should not under-consume state when required burn amount lands just below the next discrete unit.
  • That can mean ceiling in safety-critical directions, minimum-burn floors, dust-state rejection, or explicit state too coarse to proceed safely guards.
  • The sharper framing is that economic reality required more state, the runtime can only consume whole units, and the protocol will still release value against that result must not collapse into one silent floor operation.
  • The design target is not never round; it is never let rounding authorize under-collateralized exit or under-consumed debt.

2. Low-decimal assets are modeled as hostile from the start

  • Assets like WBTC should enter design review with explicit quantization risk, not as ordinary collateral with fewer decimals.
  • The same scrutiny should apply anywhere receipt-token decimals, asset decimals, and index scaling combine into a coarse effective quantum.
  • Works for 18-decimal test tokens is not evidence for safety.

3. Pathological unit-price states trigger narrower powers

4. Conversion chains are tested end-to-end, not line-by-line

  • The important object is the whole path: deposit → share mint → donation / fee / index update → collateral value → redeem / burn.
  • Healthy systems fuzz and scenario-test the exact combinations that matter in practice: low supply, high unit price, coarse decimals, same-block repeated loops, and cross-market borrowing.
  • This is how protocols catch economically needs 2 units, runtime burns 1 before production does.

5. Dust is treated as a security mode, not a leftover state

  • When supply, scaled supply, or redeemable balance collapses toward the minimum unit, healthy systems switch into a narrower operating mode.
  • They do not continue honoring mature-market semantics while the market is effectively running on one or two economically meaningful quanta.
  • Dust supply should change policy before it changes collateral truth.

Negative exemplar cluster

  • Hundred Finance hWBTC — the canonical Compound-style case where redeemUnderlying needed just under 2 hWBTC wei of burn but truncated to 1 after exchange-rate inflation made that one unit economically huge.
  • BUSD LP — a post-Hundred replay showing how low-denomination LP collateral plus tiny cToken supply still let a required 1.998-ish burn round down to 1.
  • Sonne Finance soVELO — another 1.999... -> 1 unit case proving known empty-market fixes were still incomplete when quantization risk remained live.
  • HopeLend hETHWBTC — the Aave-style WBTC case where extreme liquidityIndex plus 8-decimal granularity made one minimum hToken unit large enough to sustain repeated cash-out loops.
  • Radiant native USDC and ZeroLend PT-LBTC — reminders that even when the exploit family’s headline is index inflation or ledger divergence, the final monetization still depends on how burns and withdrawals behave at minimum-unit boundaries.

Red flags that usually mean quantization risk is being treated as “just math”

  • The rounding loss is only one wei
  • This market should never get that empty
  • WBTC only changes UX precision, not security posture
  • The library floors everywhere, so behavior is consistent
  • If exchange rate gets that high, we already have bigger problems
  • Dust balances are harmless leftovers
  • It passed tests with 18-decimal mocks

Failure-prevention checklist

  • Identify the smallest economically meaningful unit on every solvency-critical path: underlying asset, receipt token, debt share, scaled balance, and index math may all have different quanta.
  • Treat low-decimal assets and coarse receipt-token rails as hostile during listing review. Require explicit edge-state tests before collateral admission or recursive use.
  • Keep the three quantization promotions explicit in code and review: economic reality required this much state, the runtime rounded to this whole-unit result, and downstream paths are or are not allowed to spend against that rounded result as full solvency truth should not collapse into one invisible helper call.
  • Fail closed when a redeem / withdraw / liquidation / burn path would consume less state than economic reality requires because floor rounding crossed a minimum-unit boundary.
  • Add minimum-burn or ceiling semantics where the protocol must remain conservative to protect reserves, sibling markets, or bad-debt boundaries.
  • Reject or quarantine dust-supply states instead of continuing mature-market semantics once one or two units become economically large.
  • Fuzz end-to-end paths at pathological states: tiny supply, huge exchange rate, huge liquidityIndex, coarse asset decimals, and same-block repeated loops.
  • Test with the real decimal profiles that matter in production: WBTC-style 8 decimals, 6-decimal stables, ERC-4626 share decimals, and receipt tokens that do not match the underlying.
  • Review helper paths, not just primary paths. Liquidation, emergency withdraw, flash-loan settlement, and migration helpers often hit different quantization boundaries than ordinary redeem paths.
  • Monitor for one unit becoming too valuable: extreme exchange-rate or index jumps, dust supply, or a market where the next minimum unit implies outsized collateral value.
  • Require explicit recovery or recapitalization before re-enabling normal exits after low-supply collapse. Do not let ambient donations, fees, or ordinary deposits silently normalize dangerous quantized states.

Audit prompts

  • What is the smallest burnable or redeemable unit on this path, in real money terms, under the most extreme state the protocol can plausibly reach?
  • Which exact rounding direction applies in redeem, withdraw, liquidation, debt reduction, and fee settlement paths, and who benefits from each direction?
  • What upstream state would make one minimum unit economically large here: empty supply, inflated exchange rate, index capture, coarse decimals, or cross-ledger mismatch?
  • Does the protocol ever rely on this state should never happen to keep quantization harmless? If so, where is that state machine actually enforced?
  • Are asset decimals, receipt-token decimals, and index scaling reviewed together, or only component by component?
  • If economic reality says burn 1.999999 units, what exactly happens today: revert, round up, round down, clamp, or leak value?
  • Which paths were tested at real production decimal settings rather than 18-decimal mocks?
  • If one unit becomes too valuable, which powers narrow first: collateral use, borrowing, withdrawals, flash loans, or none of them?
  • Can a market remain borrow-relevant while operating on one or two economically meaningful quanta of supply?
  • What telemetry would tell operators that a market has crossed from ordinary rounding noise into quantized solvency risk?

Lessons that should already be standard

  • Only one wei is not a safety argument once that wei can temporarily represent meaningful collateral or exit rights.
  • Economic reality required ~2 units, the runtime burned 1 unit, and the rest of the protocol still spent against that 1-unit result are three different statements, not one rounding footnote.
  • Low-decimal assets are not cosmetic. They change the size of the exploitable quantum and therefore the economics of every floor-rounded path.
  • Arithmetic libraries do not choose security posture; protocol designers do. A floor-rounded helper can be perfectly correct and still be a solvency bug.
  • Empty-market and index-inflation exploits are also minimum-unit exploits. The arithmetic edge only becomes cash-outable because another control surface made the next unit too valuable.
  • Dust is a lifecycle state. When supply collapses far enough, the market should lose privileges before it loses money.
  • If a protocol has not tested economically 2 units, runtime 1 unit, it has not really tested the dangerous state yet.

How this note complements the exploit corpus

Internal linkages

Control surface

Graph View

Backlinks