solidity – Reasons Why Compiled Bytecode is Significantly Larger Than Solidity Code

bytecodeoptimizationsolidity

I'm busy optimising my Solidity contract and I noticed some behaviour I don't understand.

When I add the following two getter functions:

function getBaseReward() external view returns (uint256) {
  return _baseReward;
}

function getMaxBonuses() external view returns (uint256) {
  return _maxBonuses;
}

The compiled contract size increases by 0.12kb and the text size of the functions on their own is 0.16kb. They are not very different.

However when I add this function:

function burn(uint256 amount) external {
  onlyOwner();
  _burn(msg.sender, amount);
}

The compiled contract size increases by 0.87kb but the text size of the function is only 0.08kb. That's about 10x more and it's just calling two internal functions. Why is the size increase so out of proportion?

Best Answer

I am assuming that you are extending existing token contracts for the onlyOwner and _burn functionality.

When you do not use the function of the contract that you inherit from, the Solidity compiler will not include the bytecode of these into your contract. Therefore if you only reference your own variable the bytecode for onlyOwner and _burn is not present in the bytecode of your final contract. But as soon as you use/ reference these, the bytecode is added (including all bytecode these functions use). Therefore you need to look what code the functions include that you reference from libraries.

General comment: Comparing string size to bytecode size is not a good comparison, as function names and many other syntactic sugar, does not really increase the size of the bytecode.

Edit:

Some references:

https://docs.soliditylang.org/en/v0.8.11/internals/optimizer.html#the-optimizer

Related Solutions

Solidity: How to Access the Length of a Public Array?

Solidity creates getter functions for public state variables automatically. For example, the following will work:

contract A {
  uint256 public foo = 1;
}

contract B {
  A a;

  function getFoo() public view returns (uint256) {
    return a.foo();
  }
}

In the case of arrays however, you can only get a single element from the array, rather than the entire array. From the Solidity documentation:

If you have a public state variable of array type, then you can only retrieve single elements of the array via the generated getter function. This mechanism exists to avoid high gas costs when returning an entire array. You can use arguments to specify which individual element to return, for example data(0). If you want to return an entire array in one call, then you need to write a function.

Basically, while you can do the following:

contract A {
  uint256[] public foo;
}

contract B {
  A a;

  function getFoo() public view returns (uint256) {
    return a.foo(0); // Get item at index 0 from the array
  }
}

You cannot use a.foo() to read the entire array, and you will have to use a getter function like this for example:

contract A {
  uint256[] public foo;

  function getFooLength() public view returns (uint256) {
    return foo.length;
  }
}

contract B {
  A a;

  function getFoo() public view returns (uint256) {
    return a.getFooLength();
  }
}

solidity – Resolving Error When Returning an Array from a Function: Return Argument Type uint256[2] is Not Implicitly Convertible

Fixed length arrays (e.g. uint[2] memory) and dynamic length arrays (e.g. uint[] memory) are stored in memory differently, as the dynamic length array has to also store the length.

From the docs:

The length of a dynamic array is stored at the first slot of the array and followed by the array elements.

Due to this difference it is not possible to convert them automatically. More info is available in the Solidity docs on the internals:

Edit: An alternative for your example would be the usage of a tuple as the return type:

function length() public view returns(uint fixedLength, uint dynamicLength) { 
  return (fixedArr.length, dynamicArr.length); 
}

Best Answer

Related Solutions

Solidity: How to Access the Length of a Public Array?

solidity – Resolving Error When Returning an Array from a Function: Return Argument Type uint256[2] is Not Implicitly Convertible

Related Topic