Puppy Raffle
AI First Flight #1
Beginner FriendlyFoundrySolidityNFT
EXP
View results
Previous Next
Submission Details
Severity: high
Valid

`totalFees` is a `uint64` and is updated with an unchecked `uint64(fee)` cast under Solidity 0.7.6, so fee accounting silently truncates/overflows and `withdrawFees()` becomes permanently uncallable

0xj3d1

Root + Impact

Description

  • Each selectWinner() call adds 20% of the round's pot to totalFees, which withdrawFees() later pays out to feeAddress. withdrawFees() requires address(this).balance == uint256(totalFees).

  • totalFees is declared uint64 and updated as totalFees = totalFees + uint64(fee). Under Solidity 0.7.6 there is no built-in overflow protection, and the explicit uint64(...) cast silently truncates any fee (a uint256) that does not fit in 64 bits. Once totalFees no longer equals the real ETH balance, the strict-equality check in withdrawFees() can never pass and the fees are locked forever.

uint256 fee = (totalAmountCollected * 20) / 100;
@> totalFees = totalFees + uint64(fee); // unchecked cast + 0.7.6 wraparound
...
function withdrawFees() external {
@> require(address(this).balance == uint256(totalFees), "PuppyRaffle: There are currently players active!");
...
}

Risk

Likelihood:

  • Occurs once cumulative collected fees pass ~18.45 ETH (the uint64 ceiling) across the protocol's lifetime — a realistic threshold for a popular raffle with a non-trivial entrance fee.

  • Occurs immediately for any single round large enough that the computed fee exceeds type(uint64).max, because the uint64(fee) cast truncates before the addition.

Impact:

  • Accumulated protocol fees become permanently unwithdrawable; there is no rescue path.

  • Fee accounting reported on-chain (totalFees) silently diverges from reality, breaking any downstream assumptions.

Proof of Concept

This demonstrates the truncating cast: a fee larger than uint64 max is stored as a wrapped, smaller number.

function test_totalFees_truncates_on_cast() public {
// a single round fee exceeding uint64 max truncates at the cast
uint256 fee = uint256(type(uint64).max) + 1e18; // > uint64 ceiling
uint64 stored = uint64(fee); // mirrors contract's cast
assertLt(stored, fee); // silently truncated
// because stored != real fee, address(this).balance == uint256(totalFees)
// in withdrawFees() will never hold, locking fees permanently.
}

For a full end-to-end PoC, run enough rounds (or a large enough round) that the cumulative uint64 totalFees wraps below address(this).balance, then assert withdrawFees() reverts:

vm.expectRevert("PuppyRaffle: There are currently players active!");
puppyRaffle.withdrawFees();

Recommended Mitigation

Use uint256 for totalFees, drop the cast, and upgrade to a Solidity version with checked arithmetic.

- uint64 public totalFees = 0;
+ uint256 public totalFees = 0;
...
- totalFees = totalFees + uint64(fee);
+ totalFees = totalFees + fee;
Updates

Lead Judging Commences

ai-first-flight-judge Lead Judge about 22 hours ago
Submission Judgement Published
Validated
Assigned finding tags:

[H-05] Typecasting from uint256 to uint64 in PuppyRaffle.selectWinner() May Lead to Overflow and Incorrect Fee Calculation

## Description ## Vulnerability Details The type conversion from uint256 to uint64 in the expression 'totalFees = totalFees + uint64(fee)' may potentially cause overflow problems if the 'fee' exceeds the maximum value that a uint64 can accommodate (2^64 - 1). ```javascript totalFees = totalFees + uint64(fee); ``` ## POC <details> <summary>Code</summary> ```javascript function testOverflow() public { uint256 initialBalance = address(puppyRaffle).balance; // This value is greater than the maximum value a uint64 can hold uint256 fee = 2**64; // Send ether to the contract (bool success, ) = address(puppyRaffle).call{value: fee}(""); assertTrue(success); uint256 finalBalance = address(puppyRaffle).balance; // Check if the contract's balance increased by the expected amount assertEq(finalBalance, initialBalance + fee); } ``` </details> In this test, assertTrue(success) checks if the ether was successfully sent to the contract, and assertEq(finalBalance, initialBalance + fee) checks if the contract's balance increased by the expected amount. If the balance didn't increase as expected, it could indicate an overflow. ## Impact This could consequently lead to inaccuracies in the computation of 'totalFees'. ## Recommendations To resolve this issue, you should change the data type of `totalFees` from `uint64` to `uint256`. This will prevent any potential overflow issues, as `uint256` can accommodate much larger numbers than `uint64`. Here's how you can do it: Change the declaration of `totalFees` from: ```javascript uint64 public totalFees = 0; ``` to: ```jasvascript uint256 public totalFees = 0; ``` And update the line where `totalFees` is updated from: ```diff - totalFees = totalFees + uint64(fee); + totalFees = totalFees + fee; ``` This way, you ensure that the data types are consistent and can handle the range of values that your contract may encounter.

Support

FAQs

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

Give us feedback!