88270 sc high rescuewithdrawfromblocklisted permanently marks period from as claimed bricking future withdrawals for that period and stranding the funds in pendingwithdrawassets
Submitted on Aug 12th 2026 at 14:37:32 UTC by @Web3Vinay for Audit Comp | Firelight
- Report ID: #88270
- Report Type: Smart Contract
- Report severity: High
- Target: https://github.com/immunefi-team/audit-comp-firelight/blob/v1\\_audit\\_ready/contracts/core/FirelightVault.sol
- Impacts:
- Permanent freezing of funds
Description
Brief/Intro
A rescue of a pending (not-yet-claimable) withdrawal will cause permanent, unrecoverable loss of the withdrawn assets for the rescued user, and a permanent understatement of totalAssets() for every other LP, because rescueWithdrawFromBlocklisted sets isWithdrawClaimed[period][from] = true on a period slot that can still be re-filled by a later withdraw/redeem, and claimWithdraw treats that flag as final.
The isWithdrawClaimed flag is used as a slot-consumed marker, but the underlying slot (withdrawSharesOf[period][account]) is not single-use: _requestWithdraw credits withdrawSharesOf[currentPeriod() + 1][receiver] += ... on every request. Any withdrawal request the user books into the same period number after the rescue lands on a slot that is already flagged "claimed" and can never be paid out — not by the user, and not by RESCUER_ROLE either.
Therefore, a legitimate use of rescueWithdrawFromBlocklisted function can poison the user's period slot and permanently brick a later legitimate withdrawal into that same period
Vulnerability Details
FirelightVault.sol:845-876 — rescueWithdrawFromBlocklisted marks from as claimed without any payout ever occurring, and without any restriction on the period being already claimable:
// FirelightVault.sol:861-873
for (uint256 i = 0; i < len; i++) {
uint256 _withdrawOf = withdrawSharesOf[periods[i]][from];
if (isWithdrawClaimed[periods[i]][from]) revert AlreadyClaimedPeriod(periods[i]);
if (isWithdrawClaimed[periods[i]][to]) revert AlreadyClaimedPeriod(periods[i]);
if (_withdrawOf == 0) revert NoWithdrawalAmount(periods[i]);
withdrawSharesOf[periods[i]][to] += _withdrawOf;
withdrawSharesOf[periods[i]][from] = 0;
@> isWithdrawClaimed[periods[i]][from] = true; // <-- :870 "claimed" without a payout
...
}
There is no check that periods[i] < currentPeriod(). In practice the rescue target is the pending period, because that is where an outstanding withdrawal lives: _requestWithdraw always books into currentPeriod() + 1 (contracts/core/FirelightVault.sol:1008) and claimWithdraw only unlocks a period once period < currentPeriod() (:791). So the rescued slot is, by construction, still open for new deposits of claim rights.
_requestWithdraw re-fills the very slot that was just flagged:
// FirelightVault.sol:1008-1017
uint256 period = currentPeriod() + 1;
...
@> withdrawSharesOf[period][receiver] += sharesWithdraw; // :1017 slot is additive, not single-use
@> pendingWithdrawAssets += assets; // :1019
claimWithdraw then rejects that brand-new, fully paid-for claim right forever, because it consults the account-level flag before it ever looks at the balance:
// FirelightVault.sol:793-803
address sender = _msgSender();
@> if (isWithdrawClaimed[period][sender]) revert AlreadyClaimedPeriod(period); // :794
assets = _convertToAssetsTotals(withdrawSharesOf[period][sender], ...);
And the only escape hatch is closed by the rescue function's own guard at :864 — a second rescue of the same (period, from) reverts AlreadyClaimedPeriod, so RESCUER_ROLE cannot move the stuck entry out either. withdrawSharesOf/isWithdrawClaimed have no other writer (_requestWithdraw at :1017 and rescueWithdrawFromBlocklisted at :868-870 are the only two), so the state is terminal.
Second-order damage: the stranded assets were added to pendingWithdrawAssets at :1019 and are only ever released by claimWithdraw's pendingWithdrawAssets -= assets at :805 (or payout() at :960, which is out of window by then). Since the claim can never execute, the counter is permanently inflated, and totalAssets() is permanently deflated for every remaining LP:
// FirelightVault.sol:427-429
return super.totalAssets() - pendingWithdrawAssets;
Internal Pre-conditions
- A user has an open withdrawal request for the pending period
P = currentPeriod() + 1(withdrawSharesOf[P][user] > 0,isWithdrawClaimed[P][user] == false). BLOCKLIST_ROLEblocklists that user (compliance flag, false positive, key-compromise report, etc.).RESCUER_ROLEcallsrescueWithdrawFromBlocklisted(user, dest, [P])— the documented, intended use of the function for an outstanding withdrawal.BLOCKLIST_ROLElater un-blocklists the user (flag cleared / false positive resolved) while the chain is still inside periodP - 1, i.e. whilecurrentPeriod() + 1 == P.- The user files any new
withdraw/redeemwhile still in periodP - 1.
All four privileged steps are squarely inside documented authority. The trigger in step 5 is a permissionless, ordinary user action — the user does not know their period slot has been poisoned, and there is no view function or event that would tell them (maxClaim-style helper at :465-474 reads withdrawSharesOf only and does not consult isWithdrawClaimed).
External Pre-conditions
None.
Attack Path
Concrete numbers from the PoC (6-decimal asset, 7-day periods):
- Bob (unrelated LP) deposits
100,000fXRP. - Alice deposits
100,000fXRP and redeems all of it →withdrawSharesOf[P][alice] = 100,000e6,pendingWithdrawAssets = 100,000e6. BLOCKLIST_ROLEblocklists Alice.RESCUER_ROLEcallsrescueWithdrawFromBlocklisted(alice, aliceNew, [P])→withdrawSharesOf[P][aliceNew] = 100,000e6,withdrawSharesOf[P][alice] = 0,isWithdrawClaimed[P][alice] = true(:870) — no assets moved.BLOCKLIST_ROLEun-blocklists Alice (false positive resolved). Still inside periodP - 1.- Alice deposits
50,000fXRP and redeems →withdrawSharesOf[P][alice] = 50,000e6,pendingWithdrawAssets = 150,000e6. The flag from step 4 is stilltrue. - Two period rolls;
Pbecomes claimable.aliceNewclaims100,000fXRP successfully. - Alice calls
claimWithdraw(P)→ revertsAlreadyClaimedPeriod(P)(:794). She receives nothing. - Recovery attempt: re-blocklist Alice and call
rescueWithdrawFromBlocklisted(alice, aliceNew, [P])→ revertsAlreadyClaimedPeriod(P)at:864. No recovery path exists.
Impact
- Direct, permanent loss of
50,000fXRP for Alice in the PoC — the amount is unbounded and equals whatever the user withdraws into the poisoned period. - Irreversibly bricked state: neither the user nor
RESCUER_ROLEnor any admin function can clearisWithdrawClaimed[P][alice]or movewithdrawSharesOf[P][alice]. There is no setter, and the vault is upgradeable only via a full implementation upgrade. - Accounting broken for every other LP:
pendingWithdrawAssetsis permanently inflated by the stranded amount, sototalAssets()(:427-429) is permanently understated by the same amount. In the PoC the vault holds150,000e6raw but reportstotalAssets() = 100,000e6. This silently:- depresses the share price for all remaining holders (
_convertToAssetsTotalsdenominators), - consumes
depositLimitheadroom that will never be freed (maxDepositat:371-378), - shrinks
payout()'scurrentActiveAssetscap (:912) forever, reducing the cover the vault can honour.
- depresses the share price for all remaining holders (
- Broken invariant, exactly:
claimWithdraw's one-shot flag is asserted to be per-claim, but it is in fact a permanent per-slot marker on a slot that is re-fillable — a booked, fully-funded claim right can exist withisWithdrawClaimed == trueand zero payout ever made.
Note on the pre-declared exclusions: the privileged actors here all stay inside documented authority. The result — an ordinary user's later funds irreversibly bricked and every other LP's share accounting permanently corrupted — is the "privileged role's action produces a result outside its documented authority (breaks accounting for others, bricks state irreversibly)" carve-out, not centralization risk.
Reference
contracts/core/FirelightVault.sol:845-876 — rescueWithdrawFromBlocklisted contracts/core/FirelightVault.sol:788-811 — claimWithdraw
Proof of Concept
Proof of Concept
The project uses Hardhat, but I used Foundry as an independent testing harness for the PoC.
Run
forge test --match-test test_poc_rescueBricksFutureClaimForSamePeriod -vvvv
Test Code
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.28;
// Standalone PoC — needs only forge-std, OpenZeppelin (already a repo dependency)
// and the in-scope contract `contracts/core/FirelightVault.sol`.
//
// forge test --match-path "audit-data/poc-tests/rescue-bricks-claim.t.sol" -vvv
//
// (or drop this file into the configured `test` directory, e.g. `audit-data/foundry/`)
import {Test} from "forge-std/Test.sol";
import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {FirelightVault} from "../../contracts/core/FirelightVault.sol";
contract PocAsset {
string public name = "Mock fXRP";
string public symbol = "fXRP";
uint8 public constant decimals = 6;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function mint(address to, uint256 amount) external {
balanceOf[to] += amount;
totalSupply += amount;
emit Transfer(address(0), to, amount);
}
function approve(address s, uint256 a) external returns (bool) {
allowance[msg.sender][s] = a;
emit Approval(msg.sender, s, a);
return true;
}
function transfer(address to, uint256 a) external returns (bool) {
_t(msg.sender, to, a);
return true;
}
function transferFrom(address f, address to, uint256 a) external returns (bool) {
uint256 al = allowance[f][msg.sender];
if (al != type(uint256).max) {
require(al >= a, "allowance");
allowance[f][msg.sender] = al - a;
}
_t(f, to, a);
return true;
}
function _t(address f, address to, uint256 a) internal {
require(balanceOf[f] >= a, "balance");
balanceOf[f] -= a;
balanceOf[to] += a;
emit Transfer(f, to, a);
}
}
contract RescueBricksClaimPoC is Test {
FirelightVault internal vault;
PocAsset internal asset;
address internal admin = address(0xA11CE);
address internal blocklister = address(0xB10CC);
address internal rescuer = address(0x2E5C4E);
address internal pauser = address(0xBA05E);
address internal limitUpdater = address(0x11311);
address internal periodUpdater = address(0xBE710D);
address internal alice = address(0xA71CE); // honest user, blocklisted by mistake
address internal aliceNew = address(0xA71CE2); // rescue destination
address internal bob = address(0xB0B); // unrelated LP, suffers the accounting damage
uint48 internal constant PERIOD_DURATION = 7 days;
uint256 internal constant DEPOSIT_LIMIT = 50_000_000e6;
function setUp() public {
vm.warp(1_700_000_000);
asset = new PocAsset();
FirelightVault impl = new FirelightVault();
FirelightVault.InitParams memory p = FirelightVault.InitParams({
defaultAdmin: admin,
limitUpdater: limitUpdater,
blocklister: blocklister,
pauser: pauser,
periodConfigurationUpdater: periodUpdater,
rescuer: rescuer,
depositLimit: DEPOSIT_LIMIT,
periodConfigurationDuration: PERIOD_DURATION
});
ERC1967Proxy proxy = new ERC1967Proxy(
address(impl),
abi.encodeCall(
FirelightVault.initialize,
(IERC20(address(asset)), "Staked fXRP", "stfXRP", abi.encode(p))
)
);
vault = FirelightVault(address(proxy));
address[3] memory us = [alice, aliceNew, bob];
for (uint256 i = 0; i < us.length; i++) {
asset.mint(us[i], 1_000_000e6);
vm.prank(us[i]);
asset.approve(address(vault), type(uint256).max);
}
}
function test_poc_rescueBricksFutureClaimForSamePeriod() public {
// ---- unrelated LP provides liquidity ----
vm.prank(bob);
vault.deposit(100_000e6, bob);
// ---- 1. Alice deposits and files a withdraw request ----
vm.startPrank(alice);
vault.deposit(100_000e6, alice);
uint256 P = vault.currentPeriod() + 1; // the pending withdrawal period
vault.redeem(vault.balanceOf(alice), alice, alice);
vm.stopPrank();
assertEq(vault.withdrawSharesOf(P, alice), 100_000e6, "alice request booked");
assertFalse(vault.isWithdrawClaimed(P, alice));
// ---- 2. Alice is blocklisted (compliance flag) and her pending
// withdrawal is rescued to a fresh address ----
vm.prank(blocklister);
vault.addToBlocklist(alice);
uint256[] memory periods = new uint256[](1);
periods[0] = P;
vm.prank(rescuer);
vault.rescueWithdrawFromBlocklisted(alice, aliceNew, periods);
// FirelightVault.sol:870 -- `from` is flagged "claimed" even though nothing was paid
assertTrue(vault.isWithdrawClaimed(P, alice), "alice flagged claimed by the rescue");
assertEq(vault.withdrawSharesOf(P, alice), 0);
assertEq(vault.withdrawSharesOf(P, aliceNew), 100_000e6);
// ---- 3. The flag turns out to be a false positive; Alice is un-blocklisted
// and resumes normal use of the vault, still inside period P-1 ----
vm.prank(blocklister);
vault.removeFromBlocklist(alice);
assertEq(vault.currentPeriod() + 1, P, "still the same period, new requests land in P");
vm.startPrank(alice);
vault.deposit(50_000e6, alice);
uint256 stranded = vault.redeem(vault.balanceOf(alice), alice, alice);
vm.stopPrank();
// brand-new, fully paid-for claim right lands on an already-flagged slot
assertGt(vault.withdrawSharesOf(P, alice), 0, "new entry booked for alice");
assertTrue(vault.isWithdrawClaimed(P, alice), "...but the slot is still flagged claimed");
emit log_named_uint("assets Alice can never claim", stranded);
// ---- 4. Period P becomes claimable ----
vm.warp(uint256(vault.currentPeriodEnd()) + 1);
vm.warp(uint256(vault.currentPeriodEnd()) + 1);
assertGt(vault.currentPeriod(), P);
// the rescue destination is paid normally
vm.prank(aliceNew);
uint256 paidToNew = vault.claimWithdraw(P);
assertGt(paidToNew, 0);
// ---- 5. Alice can NEVER claim her second, legitimate withdrawal ----
uint256 aliceBalBefore = asset.balanceOf(alice);
vm.prank(alice);
vm.expectRevert(
abi.encodeWithSelector(bytes4(keccak256("AlreadyClaimedPeriod(uint256)")), P)
);
vault.claimWithdraw(P);
assertEq(asset.balanceOf(alice), aliceBalBefore, "alice received nothing");
// ---- 6. There is no recovery path, not even for RESCUER_ROLE:
// rescueWithdrawFromBlocklisted reverts at FirelightVault.sol:864 ----
vm.prank(blocklister);
vault.addToBlocklist(alice);
vm.prank(rescuer);
vm.expectRevert(
abi.encodeWithSelector(bytes4(keccak256("AlreadyClaimedPeriod(uint256)")), P)
);
vault.rescueWithdrawFromBlocklisted(alice, aliceNew, periods);
// ---- 7. Damage is not only Alice's: the stranded amount stays inside
// pendingWithdrawAssets forever, so totalAssets() (and therefore every
// remaining LP's share price) is permanently understated by it. ----
assertGe(vault.pendingWithdrawAssets(), stranded, "stranded assets stuck in pendingWithdrawAssets");
uint256 rawBalance = asset.balanceOf(address(vault));
uint256 reported = vault.totalAssets();
assertEq(rawBalance - reported, vault.pendingWithdrawAssets());
emit log_named_uint("vault raw balance ", rawBalance);
emit log_named_uint("vault totalAssets() ", reported);
emit log_named_uint("pendingWithdrawAssets stuck", vault.pendingWithdrawAssets());
// Bob is the only remaining LP; his shares are backed by assets the vault
// refuses to count, and the stuck amount can never be released.
assertGt(vault.balanceOf(bob), 0);
assertEq(vault.pendingWithdrawAssets(), stranded, "exactly Alice's second request is stuck");
}
}
Result
Ran 1 test for audit-data/foundry/Inv03_PoC_RescueBricksClaim.t.sol:RescueBricksClaimPoC
[PASS] test_poc_rescueBricksFutureClaimForSamePeriod() (gas: 886681)
Logs:
assets Alice can never claim: 50000000000
vault raw balance : 150000000000
vault totalAssets() : 100000000000
pendingWithdrawAssets stuck: 50000000000
Suite result: ok. 1 passed; 0 failed; 0 skipped
Every assertion in the test asserts the broken behaviour, so a green run is the proof: Alice's 50,000e6 is unclaimable by her, unrescuable by RESCUER_ROLE, and permanently subtracted from totalAssets() (150,000e6 held vs 100,000e6 reported).