Constants and immutables in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of constant and immutable variables in Solidity

What is the output of the following Solidity contract when calling getValues()?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Test {
    uint256 public constant CONST_VAL = 100;
    uint256 public immutable IMMUTABLE_VAL;

    constructor(uint256 _val) {
        IMMUTABLE_VAL = _val;
    }

    function getValues() public view returns (uint256, uint256) {
        return (CONST_VAL, IMMUTABLE_VAL);
    }
}

A (0, 200)

B (100, 200)

C (100, 0)

D (200, 100)

💡 Hint

Remember that constant variables are fixed at compile time, and immutable variables are set once during construction.

The constant variable CONST_VAL is set to 100 at compile time. The immutable variable IMMUTABLE_VAL is set once in the constructor to the passed value (200). So the function returns (100, 200).

🧠 Conceptual

intermediate

Understanding immutables in smart contracts

Which statement about immutable variables in Solidity is correct?

A Immutable variables can be changed multiple times after contract deployment.

B Immutable variables must be assigned a value at declaration and cannot be changed later.

C Immutable variables can be assigned once during contract construction and then cannot be changed.

D Immutable variables behave exactly like constant variables and are replaced at compile time.

💡 Hint

Think about when the value of an immutable variable is set.

Immutable variables are assigned once during the contract's constructor execution and cannot be changed afterward. This allows flexibility compared to constants, which must be assigned at compile time.

🔧 Debug

advanced

Identify the error with constant variable assignment

What error will the Solidity compiler produce for this code snippet?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Demo {
    uint256 public constant MY_CONST;

    constructor() {
        MY_CONST = 10;
    }
}

A TypeError: Constant variables must be assigned at declaration.

B SyntaxError: Missing semicolon after constant declaration.

C RuntimeError: Cannot assign to constant variable in constructor.

D No error, code compiles and runs fine.

💡 Hint

Check where constant variables must be assigned.

Constant variables must be assigned a value where they are declared. Assigning them in the constructor causes a compile-time error.

❓ Predict Output

advanced

Gas cost difference between constant and immutable

Given the following Solidity contract, which statement about gas cost when accessing CONST_VAL and IMMUTABLE_VAL is true?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract GasTest {
    uint256 public constant CONST_VAL = 123;
    uint256 public immutable IMMUTABLE_VAL;

    constructor() {
        IMMUTABLE_VAL = 456;
    }

    function readConst() public pure returns (uint256) {
        return CONST_VAL;
    }

    function readImmutable() public view returns (uint256) {
        return IMMUTABLE_VAL;
    }
}

A Reading CONST_VAL costs less gas than reading IMMUTABLE_VAL.

B Reading IMMUTABLE_VAL costs less gas than reading CONST_VAL.

C Reading CONST_VAL costs gas, but reading IMMUTABLE_VAL is free.

D Both CONST_VAL and IMMUTABLE_VAL cost the same gas to read.

💡 Hint

Consider where the values are stored and how the EVM accesses them.

Constant variables are replaced by their value at compile time and do not require storage access, so reading them costs less gas. Immutable variables are stored in storage slots and require a storage read, which costs more gas.

🧠 Conceptual

expert

Why use immutables instead of constants in Solidity?

Which is the best reason to use immutable variables instead of constant variables in Solidity?

A Immutable variables are stored in memory, constants are stored in storage.

B Immutable variables use less gas than constants when accessed.

C Immutable variables can be changed after deployment, constants cannot.

D Immutable variables allow setting values at runtime during contract deployment, while constants require compile-time values.

💡 Hint

Think about when you know the value you want to assign.

Immutable variables let you assign values during contract deployment (constructor), which is useful when the value depends on deployment parameters. Constants must have fixed values known at compile time.