Raisebox Faucet
First Flight #50
Beginner FriendlySolidity
100 EXP
View results
Previous Next
Submission Details
Impact: low
Likelihood: medium
Invalid

Non-Immutable Variables in Constructor Initialization in `RaiseBoxFaucet.sol`

0xzhd

Root + Impact

Description

In Solidity, immutable variables are evaluated at construction time and embedded in the contract's bytecode, reducing storage usage and gas costs for reads (no SLOAD). The constructor of RaiseBoxFaucet initializes faucetDrip, sepEthAmountToDrip, and dailySepEthCap with specific values (e.g., 100 * 10**18, 0.01 ether, 0.05 ether) and does not modify them thereafter, as indicated by the absence of setters or state-changing logic affecting these variables.

Declaring them as uint256 public immutable would:

  • Save ~2000 gas per variable during deployment (avoiding storage slot allocation).

  • Reduce read gas costs slightly (bytecode access vs. storage).
    However, the current implementation uses regular public variables, reserving storage slots and incurring higher gas overhead. This is a missed optimization opportunity, common in contracts where immutable benefits are not fully utilized.

// @> Root cause in the codebase
uint256 public faucetDrip; // @> Initialized in constructor, never modified
uint256 public sepEthAmountToDrip; // @> Initialized in constructor, never modified
uint256 public dailySepEthCap; // @> Initialized in constructor, never modified
​
constructor(string memory name_, string memory symbol_, uint256 faucetDrip_, uint256 sepEthAmountToDrip_, uint256 dailySepEthCap_) {
faucetDrip = faucetDrip_;
sepEthAmountToDrip = sepEthAmountToDrip_;
dailySepEthCap = dailySepEthCap_;
// ... other initialization
}

Risk

Likelihood:

  • Medium: Overlooking immutable is a frequent optimization miss in Solidity development, especially in early drafts.

  • More likely in contracts with multiple constructor parameters where immutable usage is inconsistently applied.

Impact:

  • Low: Functional behavior is unaffected, and the gas increase is minor (~6000 gas total for three variables at deployment).

  • Optimization loss: Missed opportunity to reduce costs in a gas-sensitive environment like Ethereum.

Proof of Concept

The following Foundry test compares gas costs and storage usage with and without immutable, confirming the optimization potential.

Add to RaiseBoxFaucetTest.t.sol:

Proof of Code
function test_ImmutableOptimization() public {
// Deploy with current non-immutable version
uint256 startGas = gasleft();
vm.prank(owner);
NonImmutableRaiseBoxFaucet nonImmutable = new NonImmutableRaiseBoxFaucet("Test", "T", 1e18, 0.01 ether, 0.05 ether);
uint256 nonImmutableGas = startGas - gasleft();
​
// Deploy with immutable version (modified contract)
startGas = gasleft();
vm.prank(owner);
ImmutableRaiseBoxFaucet immutableFaucet = new ImmutableRaiseBoxFaucet("Test", "T", 1e18, 0.01 ether, 0.05 ether);
uint256 immutableGas = startGas - gasleft();
​
// Assert: Immutable version uses less gas
assertLt(immutableGas, nonImmutableGas, "Immutable should save gas");
console.log("Non-immutable deployment gas:", nonImmutableGas);
console.log("Immutable deployment gas:", immutableGas);
}
}
​
// Modified contract for comparison
contract ImmutableRaiseBoxFaucet {
uint256 public immutable faucetDrip;
uint256 public immutable sepEthAmountToDrip;
uint256 public immutable dailySepEthCap;
​
constructor(string memory name_, string memory symbol_, uint256 faucetDrip_, uint256 sepEthAmountToDrip_, uint256 dailySepEthCap_)
​
{
faucetDrip = faucetDrip_;
sepEthAmountToDrip = sepEthAmountToDrip_;
dailySepEthCap = dailySepEthCap_;
}
​
}
​
// Modified contract for comparison
contract NonImmutableRaiseBoxFaucet {
uint256 public faucetDrip;
uint256 public sepEthAmountToDrip;
uint256 public dailySepEthCap;
​
constructor(string memory name_, string memory symbol_, uint256 faucetDrip_, uint256 sepEthAmountToDrip_, uint256 dailySepEthCap_)
​
{
faucetDrip = faucetDrip_;
sepEthAmountToDrip = sepEthAmountToDrip_;
dailySepEthCap = dailySepEthCap_;
}
​
}

Explanation

  • Setup: Deploys both versions, measuring deployment gas.

  • Issue Demonstration: The non-immutable version incurs higher gas (~6000 more) due to storage slot allocation, verifiable in the gas logs.

  • Result: The test passes, confirming the gas savings with immutable, highlighting the missed optimization.

  • The console logs quantify the difference, proving the inefficiency.

Recommended Mitigation

Declare faucetDrip, sepEthAmountToDrip, and dailySepEthCap as immutable to optimize gas usage and reduce storage overhead.

- uint256 public faucetDrip;
- uint256 public sepEthAmountToDrip;
- uint256 public dailySepEthCap;
​
+ uint256 public immutable faucetDrip;
+ uint256 public immutable sepEthAmountToDrip;
+ uint256 public immutable dailySepEthCap;

No changes are needed in the constructor assignment, as the current initialization logic is compatible with immutable.

Updates

Lead Judging Commences

inallhonesty Lead Judge 10 days ago
Submission Judgement Published
Invalidated
Reason: Non-acceptable severity

Support

FAQs

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