Percentage Calculation in Solidity – Using SafeMath for Calculating Percentages

safemath

I hope this question is not asked, but i googled too much and tried to find out the problem my self.

I'm trying to get a dynamic percentage using SafeMath

uint256 lowNumber = 316442921;
uint256 highNumber = 632885842;
uint256 distanceFromHigherNumber = 544386085;

In daily math i found a way to calculate that but it won't work here.

result = ((distanceFromHigherNumber - lowNumber) / (highNumber - lowNumber)) * 100;
percentage = 100 - result // in percentage should be ~ 28%

In solidity i did it this way:

uint256 result = (distanceFromHigherNumber.sub(lowNumber) / highNumber.sub(lowNumber)) * 100;
uint256 percentage = 100 - result;

It returns always 100, i guess it is maybe returning 1 instead of 0.72 and when i'm multiplying it by 100, when i play around it a little bit i get only zero or 100.

Any help please, i'm too new to solidity.

Best Answer

Solidity has no concept of floating-point numbers, so you need to work on an integer representation of your number.

Your idea is good, but the order of operations won't work on integers.

result = ((x - low) / (high - low))

Will always return a number between 0 and 1 by definition (unless you allow x < low or x > high but it wouldn't make any sense). Solidity only deals with integers, so it will return either 0 or 1, nothing in between. When you multiply this value by 100, you get either 0 or 100...

You need to multiply before doing the division, to immediately generate a number between 0 and 100 (or more depending on the precision that you are looking for).

This code returns the percentage that you are looking for when given 544386085 as parameter : 72.

pragma solidity ^0.7.0;

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.4/contracts/math/SafeMath.sol";

    contract Percentage {
    
        using SafeMath for uint256;
        
        uint256 high = 632885842;  
        uint256 low =  316442921;
        uint256 precision = 2;
    
        function getPercentage(uint256 x) public view returns (uint256) {
            
            require(x >= low, "Number too low");
            require(x <= high, "Number too high");
            
            return x.sub(low).mul(10 ** precision) / high.sub(low);
        }
    }

Btw, SafeMath is superfluous here, since if you know that x >= low and x <= high (due to the require statements) there is no overflow / undeflow possible.

Related Solutions

Solidity Compilation Error – Using SafeMath with OpenZeppelin Contracts

The reason you are getting that error is because num is of type uint8, and the sub() function of SafeMath is looking for type uint256. Additionally you declare using SafeMath for uint;, which confirms that it only works with uint256 (as uint is an alias for uint256).

There are two ways to fix it:

1) Make num a uint256 type. Your code would look as follows:

pragma solidity ^0.5.1;
library SafeMath {
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }
}

contract Underflow1 {
using SafeMath for uint;
    uint256 num= 0;
    function testf2() public returns (uint256){
    //val--;    
    num = num.sub(1);
    return num;
    }
}

2) (Not preferred) Allow SafeMath to handle type uint8. Your code would look as follows:

pragma solidity ^0.5.1;
library SafeMath {
  function sub(uint8 a, uint8 b) internal pure returns (uint8) {
    assert(b <= a);
    return a - b;
  }
}

contract Underflow1 {
using SafeMath for uint8;
    uint8 num= 0;
    function testf2() public returns (uint8){
    //val--;    
    num = num.sub(1);
    return num;
    }
}

[Ethereum] Is the SafeMath library obsolete in solidity 0.8.0

The Solidity v0.8.0 Breaking Changes Docs says:

Checks for overflow are very common, so we made them the default to increase readability of code, even if it comes at a slight increase of gas costs.

And Checking the GitHub commits for SafeMath.sol I found this commit made on February 2021 were they added the comment:

NOTE: SafeMath is no longer needed starting with Solidity 0.8. The compiler now has built in overflow checking.

The comment was later Reviewed in this other commit, with the title Review wording of SafeMath need in Solidity 0.8, and changed to:

NOTE: SafeMath is generally not needed starting with Solidity 0.8, since the compiler now has built in overflow checking.

Checking the first commit linked, we can also see a comment made in the SignedSafeMath.sol contract that said:

Signed math operations that revert on error.

I think that's like saying they are checking for overflows.

Also, the wording changes seems to be aligned with the other answer here, noticing that you may reuse safemath as library to improve operation cost for example, as the default one is more expensive now according to the docs, or to improve the ** operator for bases different to 2 or 10.

But it does seems that SafeMath is indeed generally not needed starting with Solidity 0.8

Also the top comment in the safemath library now says:

CAUTION This version of SafeMath should only be used with Solidity 0.8 or later, because it relies on the compiler's built in overflow checks.

Now the add function is :

function add(uint256 a, uint256 b) internal pure returns (uint256) {
    return a + b;
}

And an earlier implementation was:

 function add(uint a, uint b) internal pure returns (uint) {
    uint c = a + b;
    require(c >= a, "SafeMath: addition overflow");

    return c;
}

Best Answer

Related Solutions

Solidity Compilation Error – Using SafeMath with OpenZeppelin Contracts

[Ethereum] Is the SafeMath library obsolete in solidity 0.8.0

Related Topic