Cowrie Research

starlay-finance-acala-usdc-empty-market-liquidityindex-exploit-2024-02-08

14 min read

Starlay Finance Acala USDC Empty-Market liquidityIndex Exploit (2024-02-08)

  • Name: Starlay Finance Acala USDC empty-market liquidityIndex exploit
  • Date: 2024-02-08
  • Protocol: Starlay Finance
  • Chain: Acala EVM
  • Category: fresh-market initialization failure / empty-market liquidityIndex inflation / cross-market lending drain
  • Loss: about 2.2M, primarily 304,652.0407 DOT and 1,440,080.616 LDOT
  • Summary: Starlay’s Acala deployment left its USDC reserve in an empty or near-empty state where attacker-controlled positions dominated lUSDC supply. Public incident statements never published a full technical postmortem, but the onchain traces line up with the same Aave-style exploit family later seen in Radiant and dTRINITY: the attacker preserved a microscopic lUSDC position, recycled USDC through the same reserve so fees and index growth accrued to that dust supply, then borrowed real DOT and LDOT against collateral value that only existed because the empty reserve’s liquidityIndex had been distorted. The sharper lifecycle lesson is that once supplier breadth collapsed to attacker-ownable dust, the reserve had become effectively fresh again whether or not it was literally new. Acala’s later treasury-compensation proposal described the root problem as Starlay’s “wrong configurations … related to an empty USDC pool” and attributed the stolen funds to DOT / LDOT outflows.
  • Trigger / entry point:
    • Starlay’s Acala lUSDC reserve at 0x28A5AFACF605955e4c3aaF23b704C42Acd44EBb4 was effectively empty enough that the attacker could control nearly all meaningful supplier state.
    • Starlay identified attacker EOA 0xe6F6D3cd38e9BF1e118C8Fd1528D303d261BA4F7 in its first public incident notice.
    • Acala governance later described the exploit as stemming from Starlay-side misconfiguration “on the condition to get liquidated related to an empty USDC pool,” which strongly suggests the manipulated lUSDC position remained borrow-relevant when it should not have been.
    • A representative early exploit transaction, 0x73ea5ad193f381e5868b1f5edfcaf5195f9f3988ad4b925247fcd53081411ed6 in block 5500951, shows helper contract 0x009965f7127d78E26b9e4306e8231f55E6070b6f cycling USDC through the lUSDC reserve, preserving a microscopic 0.000001 lUSDC position, and emerging with 135.0000012 DOT debt / proceeds.
  • Root cause:
    • Starlay allowed an empty Acala USDC reserve to remain economically meaningful instead of treating dust-supply state as effectively fresh and forcing the market back into quarantine until supplier breadth recovered.
    • Public evidence indicates Aave-style reserve accounting was the printable variable: the attacker’s dust lUSDC position captured reserve growth that should have been spread across a healthy supplier base.
    • Starlay’s own and Acala’s public statements point to a configuration failure around liquidation / collateral conditions, meaning the manipulated lUSDC state was accepted as valid borrowing power against deeper DOT and LDOT liquidity.
    • Because no full postmortem appears to have been published, the exact parameter combination is partly inferred from explorer traces rather than a complete protocol-side disclosure.
  • Exploit path:
    1. The attacker funded Acala addresses linked to 0xe6F6D3cd38e9BF1e118C8Fd1528D303d261BA4F7 and began interacting with Starlay’s Acala USDC market on 2024-02-08.
    2. They used many short-lived helper contracts so each exploit loop could isolate a tiny lUSDC position while the main attacker account accumulated borrowed assets.
    3. In the early loop visible in tx 0x73ea5ad193f381e5868b1f5edfcaf5195f9f3988ad4b925247fcd53081411ed6, the helper contract was left with only 0.000001 lUSDC while repeatedly sending USDC into the same reserve and repaying slightly more than it borrowed, the exact pattern expected when an attacker is trying to force reserve-fee accrual into liquidityIndex while owning essentially all scaled supply.
    4. The same transaction shows the manipulated position immediately turning into borrow power: Blockscout’s decoded transfer view records 135.0000012 DOT leaving Starlay’s DOT market (0x2A43c0c220D7A2F6ca0c0B7A1130d02b0EC9Fb5E) to the helper, and then to the attacker.
    5. Later traces show the exploit scaled up into LDOT. In tx 0xe01da5c22b93abaac83aacb8f8f36ac394c0d896817576b990f6506f1cecc3b9 in block 5502196, multiple helper contracts each deposit 17,500 USDC, mint 17,500 lUSDC, and borrow 12,285.089 LDOT, while the same transaction also burns 283,251.418 lUSDC and re-mints 195,751.418 lUSDC inside attacker-controlled flow.
    6. The attacker consolidated the real assets at 0xe6F6D3cd38e9BF1e118C8Fd1528D303d261BA4F7, then began pushing DOT out through Acala EVM, Acala, and Polkadot accounts catalogued in Acala’s compensation sheet.
    7. Representative DOT cash-out transfers from the attacker EOA include 0x2fc5f95664e2ef421a1155b9da4101963fe240c77d9ac323d443a7ed036f6022 (52,000 DOT), 0x644c45c78c0c85898d0fe27d843547e9665a816bbd2a1f68e7ab25a71b811226 (50,000 DOT), and 0xcbaa10959a923ac5346eb583b653b91cc82214aa6d9ede5b8d0d9b8fdfb9c02f (20,318.894 DOT).
    8. Acala’s incident-accounting sheet attributes the final stolen total to roughly 304,652.0407 DOT and 1,440,080.616 LDOT, valued there at about $2,143,748.42, with later routing into ChangeNOW, Binance, HitBTC, WhiteBIT, Huobi, MEXC, and other identified destinations.
  • What the attacker needed to be true:
    • The Acala USDC reserve had to be empty enough that one attacker-controlled dust position could dominate lUSDC supply and reserve-index participation.
    • Reserve-fee or equivalent index-accrual logic had to credit value back into the same lUSDC market quickly enough to matter inside attacker-controlled loops.
    • Starlay had to accept the inflated lUSDC state as valid collateral or liquidation-resistant borrowing power against DOT and LDOT markets.
    • DOT and LDOT liquidity elsewhere in the protocol had to be deep enough to cash out the synthetic solvency into real assets.
    • The attacker needed workable exit rails from Acala EVM into Acala / Polkadot accounts and then onward to exchanges.
  • Technical anatomy worth remembering:
    • Starlay looks like an Acala-specific Aave-style cousin of Radiant and dTRINITY, not a Compound-style donation exploit. The printable variable was the reserve’s rebasing / index-based supplier accounting, not a cToken exchange rate.
    • The noteworthy setup is the microscopic lUSDC balance. The exploit did not need a huge honest deposit base to steal from; it needed the opposite.
    • The Acala / Polkadot execution path matters. The attacker drained value from an EVM reserve, then moved the proceeds through Acala and Polkadot-native accounts, which is why the public compensation data preserved both EVM and Substrate-side addresses.
    • This incident is also a reminder that “configuration” bugs can still be exploit-family bugs. If collateral admission and liquidation conditions are unsafe in an empty reserve, that is not just an ops mistake; it is the onchain exploit boundary.

Three reserve-authority promotions this incident collapsed

  1. A listed Acala USDC reserve existed and could be interacted with at all

    • lUSDC already existed on Acala EVM, and public-facing protocol state treated it as an admitted reserve rather than as a launch-like or quarantine object.
    • That only proved users can reach this reserve, not the reserve still has enough supplier breadth to author trustworthy accounting.

  2. That admitted reserve was over-promoted into trustworthy supplier-accounting publication

    • Once the reserve drifted into attacker-ownable dust, same-reserve USDC cycling no longer behaved like ordinary fee accrual across a healthy supplier base. It behaved like authorship over what the next liquidityIndex increment meant.
    • The dangerous promotion was accepting reserve exists and can still publish an index as if it already implied the reserve's denominator is mature enough that index growth still deserves accounting trust.
    • This is the sharper lesson than generic wrong configuration: the printable supplier-side mark stayed recognized after the reserve had become economically first-actor-capturable again.

  3. That published supplier-side mark still inherited immediate cross-market solvency authority

    • The manipulated lUSDC state did not stay local. It immediately translated into real borrow power against deeper DOT and LDOT liquidity elsewhere in Starlay.
    • In other words, reserve can still print a number, the protocol treats that number as collateral-relevant accounting, and sibling markets must already spend against it were effectively one joined state transition.
    • Healthy reserve design keeps listed, accounting publication still deserves trust, and cross-market borrow authority is live as separate promotions, especially once a reserve has drifted back toward dust supply.
  • Representative transactions and artifacts:
    • Attacker EOA: 0xe6F6D3cd38e9BF1e118C8Fd1528D303d261BA4F7
    • Acala attacker account in compensation sheet: 24mvvVXd3JXNWtJoktGwYD4T6HbufURL29T5tCFMSAj3vHNh
    • Starlay lUSDC: 0x28A5AFACF605955e4c3aaF23b704C42Acd44EBb4
    • Starlay lDOT: 0x2A43c0c220D7A2F6ca0c0B7A1130d02b0EC9Fb5E
    • Starlay lLDOT: 0xB58CB2e345E9FF3484aEAcE7595ff2334328C6b1
    • Starlay vdLDOT: 0xB72BDC7f9837c53a8FaE4A36Fc264ee62164bC42
    • USDC token on Acala EVM: 0x07DF96D1341A7d16Ba1AD431E2c847d978BC2bCe
    • DOT token precompile: 0x0000000000000000000100000000000000000002
    • LDOT token precompile: 0x0000000000000000000100000000000000000003
    • Early exploit tx: 0x73ea5ad193f381e5868b1f5edfcaf5195f9f3988ad4b925247fcd53081411ed6
    • Scaled LDOT exploit tx: 0xe01da5c22b93abaac83aacb8f8f36ac394c0d896817576b990f6506f1cecc3b9
    • Representative cash-out txs: 0x2fc5f95664e2ef421a1155b9da4101963fe240c77d9ac323d443a7ed036f6022, 0x644c45c78c0c85898d0fe27d843547e9665a816bbd2a1f68e7ab25a71b811226, 0xcbaa10959a923ac5346eb583b653b91cc82214aa6d9ede5b8d0d9b8fdfb9c02f
  • Response / mitigation:
    • Starlay publicly acknowledged the breach on 2024-02-08, paused all Acala pools, and precautionarily suspended Astar pools even while saying Astar assets were safe.
    • The team later described the incident as a USDC-liquidity-pool issue involving liquidityIndex miscalculation and invited the attacker to negotiate a whitehat-style return.
    • Acala governance later proposed partial treasury compensation for affected users, explicitly framing the issue as Starlay-side misconfiguration around an empty USDC pool.

Pattern tags

  • supplier-index-inflation
  • fresh-market-initialization-failure
  • The preserved shape is sharper than generic misconfiguration around an empty pool: Starlay let one actor own essentially all meaningful lUSDC supplier state, let same-reserve accounting growth compound into that dust position, and then let the printed supplier-side mark become immediate DOT / LDOT borrow power.
  • This was also a clean admitted reserve != mature solvency object failure. The dangerous condition was not merely USDC pool exists on Acala; it was USDC pool can still be economically authored by its next meaningful supplier.

Why the exploit worked

  • Starlay let an Acala lUSDC reserve remain borrow-relevant after supplier breadth had already collapsed into attacker-ownable dust. Whatever the exact configuration knobs were, the important structural fact is that one microscopic lUSDC position still had line-of-sight to protocol-wide solvency.
  • In that state, same-reserve accrual stopped behaving like neutral protocol income and became supplier-index authorship. The attack traces show helper contracts preserving tiny lUSDC balances while cycling USDC through the same reserve, which only matters economically if the reserve’s accounting still credits meaningful value back into whoever owns that dust supply.
  • Downstream collateral and liquidation rules imposed no second distrust boundary. Acala’s own compensation proposal describes the issue as Starlay-side misconfiguration tied to an empty USDC pool, which is the important healthy-side lesson: listed reserve, liquidation condition, and cross-market borrow authority were still one joined security object.
  • The preserved design lesson is therefore broader than one Acala parameter was wrong: empty-reserve lifecycle, supplier-index accounting, and downstream borrow admission all belonged to one security boundary, and Starlay split them apart.

Detection and audit pivots

  • Ask the lifecycle question directly: what onchain fact proves this reserve has enough supplier breadth to stop one address from re-authoring liquidityIndex meaning, and what demotes it back into quarantine if that breadth later collapses? If the answer is only the market is already listed, the control does not exist.
  • Reconstruct the whole supplier-value publication path: reserve inflow / fee logic, liquidityIndex, lUSDC supply distribution, collateral-factor logic, liquidation thresholds, and sibling-market borrow checks should all tell one coherent story before an empty reserve can matter system-wide.
  • Treat sparse public postmortems as a reason to inspect traces harder, not as a reason to flatten the issue into config bug. When helper contracts intentionally preserve microscopic receipt-token balances, reviewers should assume dust-supply capture until proven otherwise.
  • Check for a downstream distrust boundary. Can a thin reserve stay visible while collateral factor remains 0, debt caps stay negligible, flash-loan-like accrual paths stay disabled, or only isolated borrows are permitted? If not, the protocol is still trusting listed more than economically mature.
  • Follow the exit rails too. Acala / Polkadot hybrid deployments add another practical review question: once fake solvency turns into real DOT / LDOT, how quickly can those assets leave the EVM side, and what pause or routing controls still exist before they disappear into cross-environment cash-out paths?

Failure-prevention checklist

  • Do not let an admitted reserve keep cross-market borrow authority once supplier breadth has collapsed back into attacker-ownable dust. A dormant reserve should fall back into the same quarantine a fresh reserve starts in.
  • Keep collateral factor at 0, debt caps negligible, or both while a reserve is still thin enough that one helper contract or one operator cluster can dominate meaningful lUSDC supply.
  • Treat same-reserve accrual into liquidityIndex as solvency code, not harmless accounting. If fee growth, repayment surplus, or any similar reserve-side inflow can still concentrate into a dust supplier set, that path should fail closed or stop affecting borrowable collateral truth.
  • Re-open or re-harden thin reserves only with a durable denominator floor or another explicit low-supply recovery path. The market is already listed is not a substitute for a reserve state that cannot be re-authored by the next meaningful supplier.
  • Add production alerts and automated quarantine for reserve states that should almost never coexist: microscopic receipt-token supply, abnormal liquidityIndex growth, and immediate borrow power against deeper sibling markets.
  • Test helper-contract and many-wallet exploit choreography, not only single-wallet happy paths. The Starlay traces matter because the attacker preserved dust positions in disposable helpers while the main account accumulated DOT / LDOT elsewhere.
  • Put blast-radius controls underneath the market anyway: fast pauses, isolated-mode borrowing, route-specific debt caps, and downstream collateral quarantine should keep one Acala-side reserve from immediately turning fake USDC solvency into protocol-wide DOT / LDOT losses.
  • In hybrid EVM / Substrate environments, treat cash-out routing as part of mitigation design. Once the protocol knows one reserve can print borrow power, controls should assume assets may leave the EVM side quickly and should be containable before cross-environment exits complete.

Audit prompts

  • What exact onchain fact proves this lUSDC reserve is no longer economically fresh, and what restores quarantine if suppliers later redeem back toward dust?
  • Can one helper contract keep a microscopic lUSDC balance while same-reserve inflows still raise liquidityIndex enough to matter for collateral or liquidation math?
  • Which configuration surfaces make the manipulated reserve dangerous: collateral factor, liquidation threshold, eMode-like correlations, debt caps, or some Acala-specific liquidation condition that still trusted empty-reserve accounting?
  • If public disclosure stays sparse, do the traces still show the exploit family clearly enough — dust supplier state, same-reserve USDC cycling, and sibling-market DOT / LDOT outflows — that reviewers should model it as supplier-index inflation anyway?
  • What runtime signal would have caught this before the compensation sheet existed: one meaningful supplier, impossible liquidityIndex growth, repeated helper-contract dust preservation, or abnormal DOT / LDOT borrowing against tiny lUSDC balances?
  • Can the reserve remain observable while downstream trust stays off? If not, why was listed reserve still being treated as equivalent to mature collateral object?
  • Once borrowed assets leave the lending pool, what pause, bridge, or routing controls still exist before DOT / LDOT disappear from Acala EVM into Acala / Polkadot-native exit rails?

Lessons that should already be standard

  • Listed reserve is not a maturity proof. If one actor can still dominate meaningful supplier state, the reserve has not earned cross-market solvency authority.
  • Configuration bug in an empty pool is often just another name for the protocol let attacker-authored accounting become borrow truth. Those are not separate classes in practice.
  • Sparse public postmortems do not make a lending exploit less legible. When traces preserve dust receipt-token balances, same-reserve cycling, and sibling-market drains, reviewers should still classify the family and harden the design layer.
  • Dust-supply reserve capture is not only an Ethereum-mainnet fork problem. The same Aave-style accounting failure can monetize into Acala-side DOT / LDOT just as cleanly as into WETH or stablecoins elsewhere.
  • Lifecycle hardening has to survive runtime reality. A reserve can become effectively fresh again long after launch, and healthy design demotes it back into quarantine instead of honoring historical listing age.
  • Hybrid stacks need exit-aware incident design. If fake solvency can be converted into assets that quickly cross from EVM execution into other settlement domains, containment has to start before off-platform cash-out, not after.

Why this incident matters

  • Starlay is an important breadth case for the empty-market corpus because it shows the Aave-style liquidityIndex family escaping mainline Ethereum-style environments and surfacing in Acala’s EVM / Substrate hybrid stack.
  • It preserves a concrete example where public evidence was sparse but still technically rich enough to reconstruct the exploit family from reserve flows, helper-contract traces, and downstream cash-out routing.
  • It is also a useful warning against treating fresh market as only a deployment timestamp. Once an admitted reserve collapses back to attacker-ownable dust supply, the healthier security interpretation is that it has become effectively fresh again and should lose cross-market solvency authority until re-hardened.
  • More broadly, it warns against treating “launch / configuration” and “accounting” as separate categories. In empty lending markets they are often the same bug, just seen from different layers.

Internal linkages

Control surface

Graph View

Backlinks