Abstract Contracts and Interfaces

In Solidity, abstract contracts and interfaces are tools to define the structure and behavior of contracts without fully implementing all the logic. They are especially useful in large projects or when interacting with multiple contracts, ensuring consistency while allowing flexibility in implementation.

1. Abstract Contracts

An abstract contract is a contract that cannot be instantiated directly. It can contain:

Implemented functions (with code)
Unimplemented functions (without code, declared using the virtual keyword)

Derived contracts must override all unimplemented functions before deployment. Abstract contracts are useful when you want to define a template for other contracts.

Example: Abstract Contract


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

// Abstract contract
abstract contract Shape {
    // Abstract function (no implementation)
    function area() public view virtual returns (uint256);

    // Concrete function (has implementation)
    function greet() public pure returns (string memory) {
        return "Welcome to Shapes!";
    }
}

// Derived contract must implement abstract functions
contract Square is Shape {
    uint256 public side;

    constructor(uint256 _side) {
        side = _side;
    }

    // Implementing the abstract function
    function area() public view override returns (uint256) {
        return side * side;
    }
}

Explanation:

Shape is an abstract contract and cannot be deployed.
area() is abstract, so Square must override it.
greet() is concrete and can be used directly by Square.

2. Interfaces

An interface is a contract that contains only function declarations (no implementation) and cannot have state variables or constructors.

Interfaces are used to define a standard set of functions that other contracts must implement. They are particularly important for interoperability, such as interacting with external contracts like ERC20 tokens.

Rules for Interfaces

Cannot have function bodies.
All functions are implicitly external.
Cannot have state variables or constructors.
Can be implemented by multiple contracts.

Example: Interface


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

// Interface definition
interface IToken {
    function transfer(address recipient, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

// Contract implementing the interface
contract MyToken is IToken {
    mapping(address => uint256) private balances;

    constructor() {
        balances[msg.sender] = 1000; // Initial tokens to deployer
    }

    function transfer(address recipient, uint256 amount)
        external
        override
        returns (bool)
    {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        balances[recipient] += amount;
        return true;
    }

    function balanceOf(address account)
        external
        view
        override
        returns (uint256)
    {
        return balances[account];
    }
}