Solidity – Where Is the Single-parameter Version of Function Sub() Defined in SafeMath?

openzeppelinsafemathsolidityuint256

I'm going through the Ethernaut challenges to learn Solidity, and in challenge 3 ("Coin Flip"), they show the following code which subtracts 1 from the current block number:

I assumed that this "sub()" function was a built-in subtraction function, but it seems like it must be defined in OpenZeppelin's SafeMath.sol library, because when I comment out the use of SafeMath in this simple example, I get a compiler warning:

However, when I look in SafeMath.sol, I do not see a single-parameter version of the sub() function. There is only a two-parameter and three-parameter version of sub() defined there:

Where is this single-parameter version of the sub() function defined?

Best Answer

The function you have seen in SafeMath.sol :

function sub(uint256 a, uint256 b) internal pure returns (uint256) {
     return a - b;
}

Is the one that is implicitly called with block.number.sub(1). That is the case because SafeMath.sol is a library that is attached to the type uint256. You can see it in the Etherenaut challenge contract at this line :

using SafeMath for uint256;

It is described in the documentation, for the mismatching number of parameters, this is the relevant part to read :

The directive using A for B; can be used to attach functions (A) as member functions to any type (B). These functions will receive the object they are called on as their first parameter (like the self variable in Python).

But you can also use the library directly, the two syntax shown in this example are entirely equivalent :

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/utils/math/SafeMath.sol";

contract Example {

    using SafeMath for uint256;

    function withAttachedFunction() public pure returns (uint256) {
        uint256 variable = 1;

        return variable.sub(1);
    }

    function withoutAttachedFunction() public pure returns (uint256) {
        uint256 variable = 1;

        return SafeMath.sub(variable, 1);
    }
}

Obviously, using the variable.sub(...) syntax is way more convenient, and it is the intended goal of the using X for Y; statement.

I hope that answers your question.

Related Solutions

[Ethereum] How does the SafeMath library of OpenZeppelin protect your code from integer overflow

How do you use it to protect your code?

Functions of SafeMath check logic conditions of math operations.

function sub(uint256 a, uint256 b...
   assert(b <= a); // otherwise, subtracting b when (b > a) will cause integer underflow

function add(uint256 a, uint256 b...
    uint256 c = a + b;
    assert(c >= a); // if the addition will cause overflow, the values will start from 0 and c will be less than a

Do you just import it?

Three steps are required to correctly implement SafeMath in your contract:

Import the library at the top of your code.
Declare that you wish to attach the library functions to the uint256 type:

using SafeMath for uint256;
Replace each of the standard arithmetic operators in your code with the equivalent call to a SafeMath function:
- a + b becomes a.add(b)
- a - b becomes a.sub(b)
- a * b becomes a.mul(b)
- a / b becomes a.div(b)

If you omit the last step, as seems to be quite common when people are first starting out with smart contracts, then your code receives no protection whatsoever from overflows/underflows. It is just the same as if you had not included SafeMath at all. This can be verified by testing the following code:

import "./SafeMath.sol";

contract TestSafeMath {
    using SafeMath for uint256;

    function unsafeSubtract() public pure returns (uint256) {
        uint256 a = 0;
        return a - 1;
    }

    function safeSubtract() public pure returns (uint256) {
        uint256 a = 0;
        return a.sub(1);
    }
}

Even though the library has been imported, and the using statement declared, calling the first function will still return the enormously large integer value 115792089237316195423570985008687907853269984665640564039457584007913129639935, or hex FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, whereas the second function will correctly throw an exception to prevent the underflow.

[Ethereum] Where is the code for web3 version 0.20.x

Documentation can be found here: Web3 JavaScript app API for 0.2x.x

Best Answer

Related Solutions

[Ethereum] How does the SafeMath library of OpenZeppelin protect your code from integer overflow

[Ethereum] Where is the code for web3 version 0.20.x

Related Topic