Solidity VS Floating-point

Addressing the Floating Point Challenge in the Ethereum Virtual Machine: Solidity Solutions

evm — Photo by Nenad Novaković on Unsplash

The Ethereum Virtual Machine (EVM) is the heart of Ethereum’s computational universe, responsible for executing smart contracts on the Ethereum blockchain. However, just like early CPUs without an integrated Floating Point Unit (FPU), the EVM presents a unique challenge: it does not natively support floating-point arithmetic. This limitation can be a hurdle for developers, especially when dealing with operations that require fractional numbers, common in financial applications.

What is FPU, read this article: https://lotuschain.medium.com/fpu-in-cpu-a67a3bd2f5ea

In this article, we’ll explore how to effectively address this floating-point challenge within the EVM using Solidity, Ethereum’s primary programming language for writing smart contracts.

The Problem: No Native Floating-Point Support in the EVM

The EVM operates on a fixed-point arithmetic model, primarily for reasons of security and determinism essential in a blockchain environment. Floating-point operations, due to their imprecise nature, can lead to inconsistencies across different machines — a risk unacceptable for the immutability and reliability requirements of blockchain transactions.

Solidity Solutions: Emulating Floating Point Arithmetic

1. Fixed-Point Arithmetic:

Solidity supports fixed-point types, but as of my last update, these are still not fully implemented. However, developers can manually implement fixed-point arithmetic by scaling integers. This method involves treating integers as if they were fixed-point numbers, with a certain number of decimal places implied.

pragma solidity ^0.8.0;

contract FixedPointMath {
    uint constant SCALE = 1e18;  // 18 decimal places

    function add(uint a, uint b) public pure returns (uint) {
        return a + b;
    }

    function subtract(uint a, uint b) public pure returns (uint) {
        require(b <= a, "Underflow error");
        return a - b;
    }

    function multiply(uint a, uint b) public pure returns (uint) {
        return (a * b) / SCALE;
    }

    function divide(uint a, uint b) public pure returns (uint) {
        require(b > 0, "Division by zero");
        return (a * SCALE) / b;
    }
}

2. Using Libraries:

There are Solidity libraries available that handle fixed-point arithmetic, such as `ABDKMath64x64` from ABDK Consulting. These libraries offer functions for various arithmetic operations, including addition, subtraction, multiplication, and division, with fixed-point numbers.

import "ABDKMath64x64.sol"; 
// or create and use your own data type (solidity 0.8.20 or above document)

contract UsingABDKLibrary {
    function multiply(int128 a, int128 b) public pure returns (int128) {
        return ABDKMath64x64.mul(a, b);
    }
}

3. Precision and Rounding:

When implementing fixed-point arithmetic, precision and rounding are crucial considerations. It’s important to decide the level of precision needed and implement appropriate rounding mechanisms to minimize errors.

Best Practices and Considerations

- Gas Costs: Remember that more complex arithmetic operations can lead to higher gas costs. Optimize your contract’s logic to balance precision and cost.
- Overflow and Underflow: Be mindful of potential overflow and underflow in arithmetic operations. Using SafeMath or similar libraries can help mitigate these risks.
- Testing: Rigorous testing is essential. Ensure that your fixed-point arithmetic operations work as expected across a range of values and edge cases.

Conclusion

While the EVM’s lack of native floating-point support poses challenges, it’s a design choice that ensures security and consistency in the blockchain environment. By using fixed-point arithmetic, leveraging libraries, and being mindful of precision and gas costs, developers can effectively work around this limitation. As the Solidity ecosystem evolves, we can expect more robust and efficient solutions to emerge, further enhancing the capabilities of Ethereum smart contracts.

#SolidityProgramming #EthereumDevelopment #SmartContractSolutions #BlockchainTechnology #EVMChallenges