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

`totalFees` is stored as `uint64`, truncating large fees and locking ETH in the contract

cryptobloc

totalFees is stored as uint64, truncating large fees and locking ETH in the contract

Affected Contract

src/PuppyRaffle.sol

Affected Code

totalFees is declared as uint64, while fee calculations are performed as uint256.

uint64 public totalFees = 0;
uint256 fee = (totalAmountCollected * 20) / 100;
totalFees = totalFees + uint64(fee);

Description

Solidity 0.7.6 does not automatically revert on integer truncation or overflow. When fee is larger than type(uint64).max, uint64(fee) truncates the value before it is added to totalFees.

The contract's ETH balance then holds the real fee amount, but totalFees records a smaller value. withdrawFees requires exact equality between the contract balance and totalFees, so the fee address can no longer withdraw the funds.

This is realistic with ETH-denominated raffles: four players paying 25 ETH each create a 20 ETH fee, which exceeds uint64.max in wei.

Risk

The protocol can record a lower fee balance than the ETH actually held by the contract. Once this accounting mismatch occurs, the fee withdrawal guard treats the contract as having active-player funds and prevents the fee address from recovering earned protocol fees.

Impact

Medium. Protocol fees can become permanently locked after a valid raffle with a high entrance fee or enough participants. The fee address cannot withdraw the ETH even though the raffle completed.

Likelihood

Medium. The issue requires large-but-plausible fee amounts. It is especially likely if the owner configures a high-value raffle or if future deployments use expensive entrance fees.

Proof of Concept

Added test: test/AuditFindings.t.sol

Run:

forge test --match-test testUint64TotalFeesTruncatesAndLocksLargeFeeBalances -vvv

The test:

  1. Deploys a raffle with a 25 ETH entrance fee.

  2. Four players enter, collecting 100 ETH.

  3. selectWinner pays 80 ETH to the winner and leaves 20 ETH in the contract.

  4. totalFees does not equal 20 ETH because the value was truncated to uint64.

  5. withdrawFees reverts because address(this).balance != totalFees.

Recommended Mitigation

Store totalFees as uint256 and do not cast the calculated fee down to a smaller integer type. Keep fee accounting in the same unit and width as ETH balances.

uint256 public totalFees;
​
function selectWinner() external {
uint256 totalAmountCollected = players.length * entranceFee;
uint256 prizePool = (totalAmountCollected * 80) / 100;
uint256 fee = (totalAmountCollected * 20) / 100;
​
totalFees += fee;
​
// Continue winner selection, state reset, prize payout, and minting.
}
​
function withdrawFees() external {
require(address(this).balance >= totalFees, "PuppyRaffle: Insufficient fee balance");
​
uint256 feesToWithdraw = totalFees;
totalFees = 0;
​
(bool success,) = feeAddress.call{value: feesToWithdraw}("");
require(success, "PuppyRaffle: Failed to withdraw fees");
}

If storage packing is still desired, enforce a maximum entrance fee and maximum player count that guarantees the fee can never exceed the chosen integer size before deployment. Add regression tests around the maximum fee boundary and a high-value raffle that previously exceeded type(uint64).max.

Updates

Lead Judging Commences

ai-first-flight-judge Lead Judge about 1 hour 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!