Building a Library for Mathematical Operations in Solidity

By Alessandro D.P.3 min readMarch 14, 2026

Overview of the Library

A library in Solidity is a special type of contract that can contain reusable functions. Libraries are deployed only once and can be called by other contracts without needing to create a new instance. This tutorial will cover a simple library that provides basic arithmetic functions, such as addition, subtraction, multiplication, and division, along with safe operations to prevent overflow and underflow.

Key Features

Safe Math Operations: Functions that handle overflow and underflow.
Reusability: The library can be imported and used across multiple contracts.
Gas Efficiency: Optimized for minimal gas usage.

Implementation

Step 1: Create the Library

We will start by defining a library called SafeMath. This library will include functions for addition, subtraction, multiplication, and division, ensuring that they are safe against overflow and underflow.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction underflow");
        return a - b;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }
}

Step 2: Using the Library in a Contract

Next, we will create a simple contract that utilizes the SafeMath library. This contract will manage a basic token balance, allowing for safe arithmetic operations.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "./SafeMath.sol";

contract Token {
    using SafeMath for uint256;

    string public name = "MyToken";
    string public symbol = "MTK";
    uint8 public decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;

    constructor(uint256 _initialSupply) {
        totalSupply = _initialSupply * (10 ** uint256(decimals));
        balanceOf[msg.sender] = totalSupply;
    }

    function transfer(address _to, uint256 _value) public returns (bool) {
        balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
        balanceOf[_to] = balanceOf[_to].add(_value);
        return true;
    }
}

Step 3: Testing the Library

Testing is crucial for ensuring that our library functions correctly. Below is a simple test case using the Truffle framework to verify the functionality of our Token contract.

const Token = artifacts.require("Token");

contract("Token", (accounts) => {
    it("should transfer tokens correctly", async () => {
        const instance = await Token.new(1000);
        const initialBalance = await instance.balanceOf(accounts[0]);
        
        await instance.transfer(accounts[1], 100);
        
        const finalBalanceSender = await instance.balanceOf(accounts[0]);
        const finalBalanceReceiver = await instance.balanceOf(accounts[1]);
        
        assert.equal(finalBalanceSender.toString(), initialBalance.toString() - 100);
        assert.equal(finalBalanceReceiver.toString(), 100);
    });
});

Best Practices

Use Libraries: Always encapsulate common functionalities in libraries to promote reusability and maintainability.
Check for Overflows and Underflows: Use safe math operations to prevent unexpected behaviors in your smart contracts.
Gas Optimization: Minimize state variable updates and redundant calculations to reduce gas costs.
Testing: Implement comprehensive tests to cover all possible scenarios, including edge cases.

Conclusion

Creating a library for mathematical operations in Solidity not only enhances code reusability but also ensures that your smart contracts operate safely and efficiently. By following the outlined steps and best practices, you can build robust applications that handle arithmetic operations seamlessly.