Solidity – What is the Immutable Keyword?

immutablekeywordsoliditysolidity-0.6.xstate-variable

What is the immutable keyword in Solidity and how do I use it?

Best Answer

The immutable keyword was added to Solidity in 0.6.5.

State variables can be marked immutable which causes them to be read-only, but assignable in the constructor. The value will be stored directly in the code.

From the docs:

Variables declared as immutable are a bit less restricted than those declared as constant: Immutable variables can be assigned an arbitrary value in the constructor of the contract or at the point of their declaration. They cannot be read during construction time and can only be assigned once.

An example code snippet is as follows:

pragma solidity ^0.6.5;

contract TestImmutable {
    uint256 public immutable a;

    // This is a valid constructor
    constructor (uint256 _a) public {
        a = _a;
    }

    // This is invalid and will not compile
    function setA (uint256 _a) public {
        a = _a;
    }
}

It is important to note that the contract creation code generated by the compiler will modify the contract’s runtime code before it is returned by replacing all references to immutables by the values assigned to the them. This is important if you are comparing the runtime code generated by the compiler with the one actually stored in the blockchain.

Related Solutions

[Ethereum] the ‘this’ keyword in Solidity

According to this guide:

Contracts Inherit all Members from Address.

It means that this is the pointer to the current instance of the type derived from Address (in your case - current instance of Helper), and balance is a member of Address.

It helps you distinguish between contract's own balance and any other balance, like in this example:

address payable x = 0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF;
if (address(x).balance < address(this).balance) 
    address(x).transfer(10);

And here is a some kind of definition (from this doc):

this: the current contract, explicitly convertible to address

Solidity Super Keyword – What Does the Keyword `super` in Solidity Do?

The super keyword in Solidity gives access to the immediate parent contract from which the current contract is derived. When having a contract A with a function f() that derives from B which also has a function f(), A overrides the f of B. That means that myInstanceOfA.f() will call the version of f that is implemented inside A itself, the original version implemented inside B is not visible anymore. The original function f from B (being A's parent) is thus available inside A via super.f(). Alternatively, one can explicitly specifying the parent of which one wants to call the overridden function because multiple overriding steps are possible as exemplified in the example below:

pragma solidity ^0.4.5;

contract C {
  uint u;
  function f() {
    u = 1;
  }
}

contract B is C {
  function f() {
    u = 2;
  }
}

contract A is B {
  function f() {  // will set u to 3
    u = 3;
  }
  function f1() { // will set u to 2
    super.f();
  }
  function f2() { // will set u to 2
    B.f();
  }
  function f3() { // will set u to 1
    C.f();
  }
}

Best Answer

Related Solutions

[Ethereum] the ‘this’ keyword in Solidity

Solidity Super Keyword – What Does the Keyword `super` in Solidity Do?

Related Topic