Blockchain Smart Contracts with Solidity · Lesson

Libraries and Abstract Contracts

Explore how to use libraries for pure, reusable functions and abstract contracts for defining base functionalities.

Libraries and Abstract Contracts is a free Blockchain Smart Contracts with Solidity lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Blockchain Smart Contracts with Solidity learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Module: Code Reusability

Welcome to Libraries and Abstract Contracts! In this lesson, we'll explore two powerful Solidity features that enhance code reusability, modularity, and maintainability.

You'll learn how to build reusable utility functions with libraries and define common interfaces and base functionalities using abstract contracts.

What are Solidity Libraries?

Solidity Libraries are like special contracts that contain reusable code. They are designed for utility functions and cannot have state variables (with rare advanced exceptions) or hold Ether.

They are deployed once and their code can be used by many contracts.
This promotes code reuse and can be gas-efficient for complex operations.
Functions within a library are typically internal or public.

Defining a Utility Library

To create a library, you use the library keyword. Let's define a simple MathUtils library that provides basic arithmetic functions. Notice that library functions are often pure or view as they don't modify state.

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

library MathUtils {
    function add(uint a, uint b) internal pure returns (uint) {
        return a + b;
    }

    function subtract(uint a, uint b) internal pure returns (uint) {
        require(b <= a, "Subtraction overflow");
        return a - b;
    }
}

Integrating a Library

To use our MathUtils library, we link it to a data type within our contract using the using A for B; syntax. This makes the library's functions available on that data type.

Try deploying the SimpleCalculator and calling its functions!

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

library MathUtils {
    function add(uint a, uint b) internal pure returns (uint) {
        return a + b;
    }

    function subtract(uint a, uint b) internal pure returns (uint) {
        require(b <= a, "Subtraction overflow");
        return a - b;
    }
}

contract SimpleCalculator {
    using MathUtils for uint; // Attaches MathUtils functions to uint

    function performAddition(uint x, uint y) public pure returns (uint) {
        return x.add(y); // Using the library's add function
    }

    function performSubtraction(uint x, uint y) public pure returns (uint) {
        return x.subtract(y); // Using the library's subtract function
    }
}

What are Abstract Contracts?

An abstract contract is a contract that cannot be deployed on its own. It's like a blueprint or a partial implementation for other contracts.

They define functions without implementing them (abstract functions).
They can also have implemented functions and state variables.
They serve as a base for other "concrete" contracts to inherit from, ensuring a common structure.

Blueprint with Abstract Contract

An abstract contract is declared using the abstract contract keyword. It must have at least one function declared without an implementation (meaning, without curly braces {}).

These unimplemented functions must be marked virtual in the abstract contract and override in the inheriting concrete contract.

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

abstract contract BaseShape {
    string public name;

    constructor(string memory _name) {
        name = _name;
    }

    // An abstract function - no implementation here
    function getArea() public view virtual returns (uint);

    // Can also have implemented functions
    function getName() public view returns (string memory) {
        return name;
    }
}

Implementing an Abstract Contract

To use an abstract contract, another contract must inherit from it using the is keyword and provide implementations for all its abstract functions.

This ensures that any contract inheriting from BaseShape will have a getArea function, guaranteeing a common interface for all shapes.

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

abstract contract BaseShape {
    string public name;

    constructor(string memory _name) {
        name = _name;
    }

    function getArea() public view virtual returns (uint);

    function getName() public view returns (string memory) {
        return name;
    }
}

contract Circle is BaseShape {
    uint public radius;
    // For simplicity, we'll use radius^2 as area, ignoring Pi.

    constructor(uint _radius) BaseShape("Circle") {
        radius = _radius;
    }

    // Must implement the abstract function from BaseShape
    function getArea() public view override returns (uint) {
        return radius * radius;
    }
}

contract Square is BaseShape {
    uint public side;

    constructor(uint _side) BaseShape("Square") {
        side = _side;
    }

    function getArea() public view override returns (uint) {
        return side * side;
    }
}

Libraries: Key Benefits

Libraries are a great choice when you need:

Pure Functions: Operations that don't change state, like complex math, string utilities, or data conversions.
Gas Efficiency: For external libraries, the bytecode is deployed once and its functions are called via a low-cost DELEGATECALL.
Modularity: Keeps your main contracts cleaner by offloading utility logic.
Reusability: Avoids duplicating common code across multiple contracts.

Abstract Contracts: Key Benefits

Abstract contracts are essential for:

Interface Enforcement: Guaranteeing that inheriting contracts implement a specific set of functions.
Base Functionality: Providing common state variables and implemented functions that all derived contracts will share.
Design Patterns: Implementing patterns like 'template method' where a high-level algorithm is defined, but specific steps are left to concrete implementations.
Polymorphism: Allowing different concrete implementations to be treated as the same base type.

Check Your Understanding

Which of the following statements about Solidity Libraries and Abstract Contracts are TRUE?

Recap: Libraries & Abstract Contracts

In this lesson, we explored two powerful tools for structuring Solidity code: Libraries and Abstract Contracts.

Libraries provide reusable, stateless utility functions, promoting modularity and gas efficiency. They are linked to contracts to extend their functionality.
Abstract Contracts act as blueprints, defining common interfaces and base functionalities that concrete contracts must inherit and implement. They enforce structure and promote consistency.

Mastering these patterns helps you write cleaner, more maintainable, and robust smart contracts in Solidity.

Frequently asked questions

Is the “Libraries and Abstract Contracts” lesson free?

Yes — the full text of “Libraries and Abstract Contracts” is free to read here on the web, and the Blockchain Smart Contracts with Solidity course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Blockchain Smart Contracts with Solidity course, upgrade to CoddyKit PRO.

What will I learn in “Libraries and Abstract Contracts”?

Explore how to use libraries for pure, reusable functions and abstract contracts for defining base functionalities. You practise Blockchain Smart Contracts with Solidity with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Blockchain Smart Contracts with Solidity?

No prior experience is required. Blockchain Smart Contracts with Solidity on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Libraries and Abstract Contracts” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Blockchain Smart Contracts with Solidity lesson?

Yes. Every Blockchain Smart Contracts with Solidity lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

Inheritance and Interfaces
Libraries and Abstract Contracts
Error Handling with Revert/Require
Modifiers and the Checks-Effects-Interactions Pattern

← Back to Blockchain Smart Contracts with Solidity