[Ethereum] Breaking one large contract to multiple smaller contracts

oraclessolidity

I'm building a project which has the following artifacts:

the complete code for Oraclize API, inline, (1329 lines of code
including comments and description)
SafeMath Library, inline, (114 lines of code)
a contract called Ownable which has codes to change owner, modifiers
related to owner etc. this contract is small (around 80 lines)
the main project contract which is large (around 1300 lines of code,
including comments and function description)

all these four artifacts are inline in the same file called ProjectName.sol.

I'm unable to deploy this project using truffle as I believe the size limit of the project has been exceeded (24576 bytes). Can you please tell me what would be the industry standard (best practice) to break this code into multiple contracts?

Best Answer

Having all contracts in a single file is most probably not the problem. It looks like your contract with 1300 lines of code is too large.

Moreover, you should look for your new statements, since they will include all the code of the contract to be instantiated. Factory pattern is a possibility to navigate around this.

contract A {}

contract AFactory {
    function createA() public returns(A) {
        return new A();
    }
}

contract B {
    AFactory fac;
    constructor(AFactory _fac) {fac = _fac;}
    ...
        fac.createA()
    ...
}

This will reduce the code size of the B contract since A code is not included, because new statement is in AFactory.

UPDATE another way to reduce the code size of a contract is to use delegation instead of inheritance. See https://refactoring.guru/replace-inheritance-with-delegation

It's difficult to tell more without seeing the code.

Related Solutions

[Ethereum] One .sol File And Multiple Contracts With Truffle

Try to change the deploy script as follows

var HumanStandardToken = artifacts.require("HumanStandardToken")

module.exports = function(deployer) {
  deployer.deploy(HumanStandardToken, '800000000000000000000000000', 'CoinName', 18, 
    'MDC',{gas: 4700000})
};

This way you're deploying the HumanStandardToken rather than the abstract base class.

Solidity Inheritance – Issues with Multiple Contracts and Inheritance in Solidity

At compilation all contracts are combined together to produce one bytecode so inheritance will not be very helpful to decrease contract size.

From the error message the problem seems to be not enough gas and it appears you are using the default gas 6.7M gas. For reference at this moment mainnet has a block gas limit above 12M gas.

A temporary solution is increasing the block gas limit.

For truffle edit the network configuration and add gas parameter.

networks: {
  development: {
    host: "127.0.0.1",
    port: 8545,
    network_id: "*",
    websockets: true,
    gas: 12000000          // <--- Increased block gas limit
  },

For ganache-cli pass requested gas to -l parameter:
```
  ganache-cli -l 12000000
```

An alternative to have separate contract is using libraries to separate functionality. It requires more planning to separate into libraries and adjusting the migrations scripts to deploy and link libraries into main contracts.

pragma solidity >=0.4.0 <0.8.0;
pragma experimental ABIEncoderV2;

library PizzaLib {
    struct Pizza {
        uint256 ingredients;
    }

    function mix(Pizza calldata pizza, uint256 ingredients) external pure returns (Pizza memory) {
        Pizza memory p = pizza;
        p.ingredients = ingredients;
        return p;
    }
}

contract PizzaShop {
    using PizzaLib for PizzaLib.Pizza;
    
    function foo() public pure returns (PizzaLib.Pizza memory) {
        PizzaLib.Pizza memory pizza;
        pizza = pizza.mix(23);
        return pizza;
    }
}

For example migrations will look like

module.exports = async function(deployer, network, accounts) {
  await deployer.deploy(PizzaLib);
  await deployer.link(PizzaLib, PizzaShop);
  await deployer.deploy(PizzaShop);
}

Best Answer

Related Solutions

[Ethereum] One .sol File And Multiple Contracts With Truffle

Solidity Inheritance – Issues with Multiple Contracts and Inheritance in Solidity

Related Topic