Interfaces

In Solidity, interfaces are a mechanism that allow you to define a contract API (Application Programming Interface) and specify the functions and variables that a contract must implement. Interfaces are a key concept in programming that allow you to define a contract’s API and ensure that it is implemented consistently across different contracts. In this article, we’ll take a closer look at interfaces in Solidity, including how to define and use interfaces, how to implement interface functions in contracts, and how to interact with external contracts using interfaces.

Defining Interfaces

In Solidity, interfaces are defined using the “interface” keyword followed by the interface name and a set of curly braces containing the functions and variables that the interface defines. The functions and variables in an interface are called “interface functions” and “interface variables”, respectively.

Interface functions and variables are defined in the same way as regular contract functions and variables, with the exception that they do not have a function body or variable value. Instead, they only specify the name, visibility, and parameter types of the functions and variables.

For example, the following code defines an interface called “SimpleInterface” with a single function called “function1”:

interface SimpleInterface {
  function function1(uint256 a) public;
}

This code defines an interface called “SimpleInterface” with a single function called “function1” that takes a single “uint256” parameter called “a”. The “public” visibility modifier specifies that the function can be called from any contract or external address.

Using Interfaces

In Solidity, interfaces are used to specify the functions and variables that a contract must implement. To use an interface in a contract, use the “is” keyword followed by the name of the interface.

For example:

contract SimpleContract is SimpleInterface {
  function function1(uint256 a) public {
    console.log("This is function1.");
  }
}

This code defines a contract called “SimpleContract” that implements the “function1” function of the “SimpleInterface” interface. The “function1” function in the “SimpleContract” contract must have the same name, visibility, and parameter types as the “function1” function in the “SimpleInterface” interface.

Implementing Interface Functions

In Solidity, interface functions are implemented in contracts using the same syntax as regular contract functions. To implement an interface function, define a function with the same name, visibility, and parameter types as the interface function in the contract.

For example:

contract SimpleContract is SimpleInterface {
  function function1(uint256 a) public {
    console.log("This is function1.");
  }
}

This code defines a contract called “SimpleContract” that implements the “function1” function of the “SimpleInterface” interface. The “function1” function in the “SimpleContract” contract has the same name, visibility, and parameter types as the “function1” function in the “SimpleInterface” interface, and therefore satisfies the requirements of the interface.

Interacting with External Contracts

In Solidity, interfaces can be used to interact with external contracts in a type-safe manner. To interact with an external contract using an interface, use the “interface” keyword followed by the contract’s address and the name of the interface.

For example:

contract SimpleContract {
  SimpleInterface externalContract = SimpleInterface(0x1234567890);
  
  function callExternalFunction() public {
    externalContract.function1(42);
  }
}

This code defines a contract called “SimpleContract” that interacts with an external contract at the address “0x1234567890” using the “SimpleInterface” interface. The “callExternalFunction” function in the “SimpleContract” contract calls the “function1” function of the external contract using the “externalContract” interface.

Interfaces and Type Checking

In Solidity, interfaces can be used to perform type checking on contracts and ensure that they implement the required functions and variables. To perform type checking on a contract using an interface, use the “is” keyword followed by the name of the interface and the contract instance.

For example:

contract SimpleContract {
  function checkContractType(address contractAddress) public {
    SimpleInterface contractInstance = SimpleInterface(contractAddress);
    if (contractInstance.isSimpleInterface()) {
      console.log("This is a SimpleInterface contract.");
    } else {
      console.log("This is not a SimpleInterface contract.");
    }
  }
}

This code defines a contract called “SimpleContract” that performs type checking on a contract instance using the “SimpleInterface” interface. The “checkContractType” function takes an “address” parameter called “contractAddress” and creates a contract instance using the “SimpleInterface” interface. The “isSimpleInterface” function is a built-in function in Solidity that returns “true” if the contract instance implements the “SimpleInterface” interface and “false” otherwise.

Conclusion

In conclusion, interfaces in Solidity are a powerful mechanism for defining contract APIs and interacting with external contracts. Interfaces allow you to specify the functions and variables that a contract must implement, and they enable you to perform type checking on contracts to ensure that they implement the required APIs. Understanding interfaces is an important aspect of developing contracts and decentralized applications in Solidity.

Exercises

To review these concepts, we will go through a series of exercises designed to test your understanding and apply what you have learned.

pragma solidity ^0.7.0;

interface Purchasable {
    function buy(address buyer) external returns (bool);
}

pragma solidity ^0.7.0;

import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/math/SafeMath.sol";

interface Purchasable {
    function buy(address buyer) external returns (bool);
}

contract Product is Purchasable {
    using SafeMath for uint;
    uint public price;

    constructor(uint _price) public {
        price = _price;
    }

    function buy(address buyer) public returns (bool) {
        require(buyer.balance >= price, "Insufficient balance");
        buyer.transfer(price);
        return true;
    }
}

pragma solidity ^0.7.0;

import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/math/SafeMath.sol";

interface Purchasable {
    function buy(address buyer) external returns (bool);
}

contract Marketplace {
    mapping(uint => Purchasable) public products;
    mapping(uint => uint) public prices;

    function listProduct(Purchasable product, uint price) public {
        products[product.id()] = product;
        prices[product.id()] = price;
    }

    function buyProduct(uint productId, address buyer) public {
        require(products[productId].buy(buyer), "Purchase failed");
    }
}

In the Solidity contract below, create an interface called “Token” that has a function called “transfer” that takes in two arguments: a “to” address and an “amount” uint. The function should not have a return value.

pragma solidity ^0.7.0;

contract MyContract {
    // Your code here
}

pragma solidity ^0.7.0;

contract MyContract {
    interface Token {
        function transfer(address to, uint amount) public;
    }
}

In the Solidity contract below, create a struct called “User” that has two fields: a “name” string and an “age” uint. Then, create a mapping called “users” that maps a user’s address to their User struct.

pragma solidity ^0.7.0;

contract MyContract {
    // Your code here
}

pragma solidity ^0.7.0;

contract MyContract {
    struct User {
        string name;
        uint age;
    }

    mapping(address => User) users;
}