🔍 Solidity’s Precision Paradox: Understanding Integer Limitations

Greetings from V-Spot!

Solidity, the backbone of many Ethereum contracts, has an inherent challenge: Precision. Here’s a deep dive into this crucial topic and a practical PoC for clarity.

📖 The Issue: In Solidity, the absence of floating point numbers and limitations around fixed point numbers can lead to inaccuracies. Especially when division comes into play, the result can often lack precision due to the rounding down of integer results.

✍️ Illustrative Scenario: Consider a smart contract that levies a fee for early withdrawals based on the number of days ahead of the scheduled withdrawal:

uint256 daysEarly = withdrawalsOpenTimestamp - block.timestamp / 1 days; uint256 fee = amount / daysEarly * dailyFee;

Here, if a user opts to withdraw just shy of 2 days early (1.99 days), the daysEarly will inaccurately round down to 1, hence charging only half the intended fee!

🛠️ Mitigation: To minimize these precision errors, a typical solution involves using fixed point logic. Essentially, scale integers to a large enough magnitude so the imprecision becomes negligible. The common scale factor is 1e18, often termed as ‘WAD’.

💡 PoC – Improved Precision in Solidity:

uint256 WAD = 1e18; uint256 scaledAmount = amount * WAD; uint256 daysEarly = withdrawalsOpenTimestamp - block.timestamp / 1 days; uint256 fee = scaledAmount / (daysEarly * WAD) * dailyFee;

By multiplying amount by WAD before performing the division, and then dividing the result by WAD, we ensure that the calculation remains precise until the very end, greatly reducing potential inaccuracies.

Remember, in the world of smart contracts, even minor inaccuracies can lead to major consequences. Always aim for precision!

Craving more insights and advanced tutorials? Dive deeper with us on V-Spot’s Solidity Precision Guide.

Until next time, code wisely!
The V-Spot Team