Handling Decimals in Complex Math within Solidity Contracts

contract-debuggingcontract-designcontract-developmentsolidity

I'm a bit lost on what to do with the following calculation. The problem is that decimals are being round up/down, which obviously doesn't give me the result I desire.

int totalValue = 275000;
int percentage = 2;

for (uint i = 0; i < 30; i++) {
  totalValue += totalValue * percentage / 100;
}

With the above code, the result is:

The expected result is:

498124.436

I know that normally you could simply use the following calculation to work with a predetermined amount of decimals like so:

value * 10**4 (4 decimals)

But I haven't gotten that to work in this case, often resulting in insanely high numbers due to the multiplication and division that "do not make sense" once I revert the above calculation using:

value / 10**4

Thank you very much for your time. Any help would be very much appreciated!

Best Answer

You need to multiply before calculations and divide after that:

int decimals = 4;
int totalValue = 275000;
int percentage = 2;

totalValue = totalValue * 10**decimals;
for (uint i = 0; i < 30; i++) {
  int AddValue = totalValue * percentage;
  AddValue = AddValue / 100;
  totalValue += AddValue;
}
totalValue = totalValue / 10**decimals;

EDIT: fixed line 5 and the percentage calculation EDIT2: Actually you don't need to multiply the percentage and will get better results - fixed

Related Solutions

Solidity Delegatecall – How Delegatecall Works from Solidity 0.5.0 Onwards

The delegatecall arguments are incorrect, you should use:

function delegatedCalculation(uint firstNumber, uint secondNumber) public {
        bool status;
        bytes memory result;
        (status, result) = linkedContract.delegatecall(abi.encodePacked(bytes4(keccak256("calculate(uint256,uint256)")), firstNumber, secondNumber));
    }

Or simply you can write the following if there is no return value, as this is the case for your calculate, method:

function delegatedCalculation(uint firstNumber, uint secondNumber) public {
        (bool status,) = c2.delegatecall(abi.encodePacked(bytes4(keccak256("calculate(uint256,uint256)")), firstNumber, secondNumber));
}

Note that:

To calculate the selector you should use uint256 not uint.
Use abi.encodePacked to pack all the parameters into a bytes type.
delegatecall will return a bool indicating success or failure and a bytes with the returned value (if any)

Test it in remix and it works. Hope this helps you.

EDIT: The clarification made in the docs is in the breaking changes section, this is probably what you were looking for.

The functions .call(), .delegatecall(), staticcall(), keccak256(), sha256() and ripemd160() now accept only a single bytes argument. Moreover, the argument is not padded. This was changed to make more explicit and clear how the arguments are concatenated. Change every .call() (and family) to a .call("") and every .call(signature, a, b, c) to use .call(abi.encodeWithSignature(signature, a, b, c)) (the last one only works for value types). Change every keccak256(a, b, c) to keccak256(abi.encodePacked(a, b, c)). Even though it is not a breaking change, it is suggested that developers change x.call(bytes4(keccak256("f(uint256)"), a, b) to x.call(abi.encodeWithSignature("f(uint256)", a, b)).

Functions .call(), .delegatecall() and .staticcall() now return (bool, bytes memory) to provide access to the return data. Change bool success = otherContract.call("f") to (bool success, bytes memory data) = otherContract.call("f").

You can check sample for call and delegatecall with solidity 0.5 here: https://gist.github.com/Muhammad-Altabba/55ac6974ac9396d723fdfd792d51eb5d

Best Answer

Related Solutions

Solidity Delegatecall – How Delegatecall Works from Solidity 0.5.0 Onwards

Related Topic