Unchecked Arithmetic and Unsafe Downcasting Corrupt Fee Accounting
Root + Impact
Description
The contract uses unchecked arithmetic and downcasts fees from uint256 to uint64 when accumulating protocol fees. In Solidity 0.7.6, arithmetic operations don't revert on overflow, and the downcast silently truncates values that exceed 64 bits. This can corrupt totalFees and eventually lock funds.
In selectWinner(), the fee calculation and accumulation looks like this:
If fee exceeds type(uint64).max (approximately 18.4 ETH), the high-order bits get discarded without warning.
Risk
Likelihood:
High — Leads to permanent fund lock under certain conditions.
Impact:
When the cast truncates, totalFees no longer reflects the actual fees collected. This breaks the accounting invariant and has two serious consequences:
-
Immediate fee loss — The protocol permanently loses the truncated portion of fees
Withdrawal lockout —
withdrawFees()requiresaddress(this).balance == uint256(totalFees), which will never be true once the accounting diverges
The result is that the owner can't withdraw accumulated fees, even though the ETH is sitting in the contract.
Proof of Concept
The vulnerability requires collecting enough fees to overflow uint64. With a 20% fee structure:
While large, these thresholds are reachable for popular raffles, especially those that run for extended periods or have low entry fees.
Recommended Mitigation
Use Solidity 0.8.x (which has built-in overflow checks) or import SafeMath for 0.7.6. Store totalFees as uint256 instead of uint64:
This eliminates both the overflow risk and the unsafe downcast.
Lead Judging Commences
[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.
Rewards breakdown
Live
The contest is live. Earn rewards by submitting a finding.
Judging
Submissions are being reviewed by our AI judge. Results will be available in a few minutes.
View all submissionsRewards Distribution
The contest is complete and the rewards are being distributed.