Solidity – Contract vs Library vs Struct vs Interface: A Detailed Comparison

contract-developmentinterfaceslibrarysoliditystruct

First I googled and read through these questions:

Creating multiple contracts or Single contract with struct

Why are so many examples using separated contracts (e.g. crowed sale contracts in zeppelin…)? IF I got all this right in most cases it would make sense to NOT use separated contracts. It would not even make sense to use libs and interfaces. Imho an interface makes sense if I do not have to pay gas for execution. But we are on a blockchain and want to keep contracts as "slim"/"light" as possible. Therefore I would even only copy the code functions I need out of a lib (only use the whole lib if I use all functions). Use the interface only for checking and debugging…

Best Answer

There are two separate reasons you would want to separate your logic into more than one contracts / libraries / etc.

1- Modularity, ease of use, ease of maintenance. If you forgo the usage of libraries or inheritance from other contracts your code go be a huge file with dozens of functions, which is hard to maintain, read, reuse, etc.

2- Implementing parent/child contracts has more to do with the logic of your code. For example, for a bidding app, you could have one contract that stores all the bids going on with their corresponding data (bidders, winning bid, etc) OR, you could create Bid contracts that each one holds the logic on their own, and then a parent contract that keeps a reference to every bid contract that gets created.

Each approach has it's own pros and cons and it really depends on what the requirements are for your application.

Related Solutions

[Ethereum] How to create Interface to read Struct in mapping

There is no way to do this in a stable version of solidity, but possible in experimental

pragma experimental ABIEncoderV2;

interface CupInteraface {
    struct S {
        bytes32 s;
    }
    function get(bytes32 cup) external returns (S memory);
}

contract Cup is CupInteraface {
    mapping(bytes32 => S) private _cups;

    constructor(bytes32 cup) public {
        _cups[cup] = S(cup);
    }

    function get(bytes32 cup) public returns (S memory) {
        return _cups[cup];
    }
}

solidity – Understanding Interfaces in Contracts – Detailed Explanation

You're correct, they can be used under an inheritance model as you pointed out above. Also take for example the IERC20 interface which is both used for almost every token and also to define other interfaces such as IERC20Metadata. Inheriting from an interface forces you to define implementations for those methods too.

But another feature is that they provide an interface for your Contract to interact with already deployed ones such as the UniswapRouter.

// https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/interfaces/IUniswapV2Router02.sol
import "./../interfaces/IUniswapV2Router.sol"; 

contract MyContract {

   address UNISWAP_V2_ROUTER = 0x....;

    function swap(...) external {
        uint[] memory out_amounts = IUniswapV2Router02(UNISWAP_V2_ROUTER).swapExactTokensForTokens(
            amount, // amountIn
            minOut, //The minimum amount we want to receive, taking into account slippage
            path, // Path
            beneficiary, // To address
            block.timestamp + 60 // Deadline
        );

    }

}

The approach without using interfaces would be a direct .call() using abi.encodeWithSignature, which is uglier and more difficult to work with.

Best Answer

Related Solutions

[Ethereum] How to create Interface to read Struct in mapping

solidity – Understanding Interfaces in Contracts – Detailed Explanation

Related Topic