BattleChain Confidence Pools
Cyfrin
FoundrySolidityLayer 2
7.25 ETH
View all submissions
Previous Next
Submission Details
Impact: high
Likelihood: medium

Post-expiry CORRUPTED state can retroactively forfeit an already expired pool

Author Revealed upon completion

Description

When a pool reaches expiry while the registry is still in an active-risk state, the protocol design says the pool survived its covered term. claimExpired() should resolve the pool as EXPIRED, allowing stakers to claim principal plus bonus.

The issue is that claimExpired() does not bind resolution to the registry state at expiry. When no one calls claimExpired() immediately at expiry and the registry later becomes CORRUPTED, the first later caller can resolve the already-expired pool as bad-faith CORRUPTED. This lets a post-term corruption retroactively forfeit stakers' expired claims.

function claimExpired() external nonReentrant {
if (block.timestamp < expiry) revert PoolNotExpired();
​
if (outcome == PoolStates.Outcome.UNRESOLVED) {
@> IAttackRegistry.ContractState state = _observePoolState();
​
@> if (state == IAttackRegistry.ContractState.CORRUPTED && riskWindowStart != 0) {
@> if (block.timestamp < expiry + MODERATOR_CORRUPTED_GRACE) {
revert AgreementCorruptedAwaitingModerator();
}
​
@> outcome = PoolStates.Outcome.CORRUPTED;
@> corruptedReserve = snapshotTotalStaked + snapshotTotalBonus;
@> claimsStarted = true;
return;
}
​
outcome = PoolStates.Outcome.EXPIRED;
}
}

Risk

Likelihood:

  • A pool expires while the registry is still active-risk.

  • No user calls claimExpired() before the registry later becomes CORRUPTED.

  • After the moderator grace period, any address can finalize the pool using the later CORRUPTED state.

Impact:

  • Stakers permanently lose principal and bonus even though the pool had already expired before the corruption.

  • The full pool balance is swept to recoveryAddress through claimCorrupted().

Proof of Concept

Add this test to test/unit/ClaimExpiredRegistryGate.t.sol:

function testAudit_PostExpiryCorruptionCanRetroactivelyForfeitExpiredPool() external {
_stake(alice, 100 * ONE);
_stake(bob, 50 * ONE);
_contributeBonus(carol, 30 * ONE);
​
uint256 expiryTs = pool.expiry();
​
attackRegistry.setAgreementState(IAttackRegistry.ContractState.UNDER_ATTACK);
pool.pokeRiskWindow();
​
vm.warp(expiryTs);
​
vm.warp(expiryTs + 1 days);
attackRegistry.setAgreementState(IAttackRegistry.ContractState.CORRUPTED);
​
vm.warp(expiryTs + pool.MODERATOR_CORRUPTED_GRACE());
vm.prank(dave);
pool.claimExpired();
​
assertEq(uint256(pool.outcome()), uint256(PoolStates.Outcome.CORRUPTED));
​
uint256 recoveryBefore = token.balanceOf(recovery);
pool.claimCorrupted();
​
assertEq(token.balanceOf(recovery) - recoveryBefore, 180 * ONE);
assertEq(token.balanceOf(alice), 0);
assertEq(token.balanceOf(bob), 0);
}

Run:

forge test --match-test testAudit_PostExpiryCorruptionCanRetroactivelyForfeitExpiredPool -vvv

Expected output:

[PASS] testAudit_PostExpiryCorruptionCanRetroactivelyForfeitExpiredPool()

Recommended Mitigation

Do not allow a CORRUPTED state first observed after expiry to retroactively choose the CORRUPTED branch. An expired pool should resolve from the state at expiry, or require the terminal CORRUPTED observation to have happened before expiry.

+ uint32 endBeforeObserve = riskWindowEnd;
IAttackRegistry.ContractState state = _observePoolState();
​
- if (state == IAttackRegistry.ContractState.CORRUPTED && riskWindowStart != 0) {
+ if (
+ state == IAttackRegistry.ContractState.CORRUPTED
+ && riskWindowStart != 0
+ && endBeforeObserve != 0
+ && endBeforeObserve <= expiry
+ ) {

Support

FAQs

Can't find an answer? Chat with us on Discord, Twitter or Linkedin.

Give us feedback!