Constants and immutables in Blockchain / Solidity - Deep Dive

Overview - Constants and immutables

What is it?

Constants and immutables are special types of variables in blockchain programming that cannot be changed after they are set. Constants are fixed values known at compile time, while immutables are set once during contract creation and then stay the same. They help keep important data safe and predictable throughout the life of a smart contract.

Why it matters

Without constants and immutables, smart contracts could accidentally or maliciously change critical values, causing bugs or security risks. They make contracts more reliable and cheaper to run by saving storage and gas costs. Imagine a contract where the owner address or token supply could change unexpectedly — that would break trust and functionality.

Where it fits

Before learning constants and immutables, you should understand basic variables and how smart contracts store data. After this, you can learn about gas optimization, security best practices, and advanced contract design patterns that rely on fixed data.

Mental Model

Core Idea

Constants and immutables are like locked boxes that hold values which cannot be changed after being set, ensuring safety and efficiency in smart contracts.

Think of it like...

Think of constants as a printed recipe on a cookbook page — it never changes. Immutables are like writing a recipe on a whiteboard once before cooking starts and then never erasing it during the meal preparation.

┌───────────────┐       ┌───────────────┐
│   CONSTANT    │       │  IMMUTABLE    │
│ (fixed value) │       │ (set once at  │
│ known at      │       │ contract init)│
│ compile time  │       │               │
└──────┬────────┘       └──────┬────────┘
       │                       │
       │                       │
       ▼                       ▼
  Value never changes   Value set once, then fixed
  throughout contract   throughout contract
  lifetime             lifetime

Build-Up - 7 Steps

1

Foundation

Understanding Variables in Smart Contracts

Concept: Learn what variables are and how they store data in smart contracts.

Variables are like labeled boxes in a contract that hold information such as numbers, addresses, or text. You can change the contents of these boxes anytime unless they are special types like constants or immutables.

Result

You know how to declare and use normal variables in a smart contract.

Understanding variables is essential because constants and immutables are special kinds of variables with extra rules.

2

Foundation

What Are Constants in Blockchain Code

Concept: Introduce constants as variables whose values never change and are set at compile time.

Constants are declared with the keyword 'constant' and must be assigned a value when declared. This value cannot be changed later. For example, a constant can store a fixed token symbol or a maximum supply number.

Result

You can declare constants that hold fixed values in your contract code.

Knowing constants helps you protect important values from accidental changes and saves gas by embedding values directly in the code.

3

Intermediate

Introducing Immutables in Smart Contracts

Concept: Immutables are variables set once during contract creation and then never change.

Unlike constants, immutables get their value when the contract is deployed, not at compile time. They use the 'immutable' keyword and can store values like the owner address or initial configuration that you only know when deploying.

Result

You can declare immutables that are set once and then fixed for the contract's life.

Immutables combine flexibility and safety by allowing one-time setup while preventing later changes.

4

Intermediate

Gas Savings with Constants and Immutables

🤔Before reading on: do you think constants and immutables cost more or less gas than regular variables? Commit to your answer.

Concept: Constants and immutables reduce gas costs compared to regular variables because they avoid storage reads and writes.

Constants are replaced by their values directly in the bytecode, so no storage is used. Immutables are stored in a special way that is cheaper to access than normal storage variables. This makes transactions cheaper when using them.

Result

You understand how using constants and immutables can save money when running contracts.

Knowing gas savings encourages writing efficient contracts that cost less to use and deploy.

5

Intermediate

Syntax Differences Between Constants and Immutables

Concept: Learn how to declare constants and immutables differently in code.

Constants require assignment at declaration and use uppercase naming by convention. Immutables are declared with 'immutable' and assigned in the constructor or at declaration. For example: contract Example { uint256 public constant MAX_SUPPLY = 1000; address public immutable owner; constructor(address _owner) { owner = _owner; } }

Result

You can write correct code using both constants and immutables.

Understanding syntax prevents bugs and enforces best practices in contract design.

6

Advanced

Security Benefits of Constants and Immutables

🤔Before reading on: do you think constants and immutables can prevent all contract bugs? Commit to your answer.

Concept: Using constants and immutables helps prevent accidental or malicious changes to critical data, improving contract security.

Because these variables cannot be changed after set, attackers or faulty code cannot alter them to break contract logic. For example, the owner address stored as immutable cannot be changed to a malicious one later.

Result

You see how constants and immutables contribute to safer smart contracts.

Knowing this helps you design contracts that are more robust and trustworthy.

7

Expert

Compiler and EVM Handling of Constants and Immutables

🤔Before reading on: do you think constants and immutables are stored the same way in the Ethereum Virtual Machine? Commit to your answer.

Concept: Constants are embedded in bytecode, while immutables are stored in special slots accessible via code but cheaper than normal storage.

The compiler replaces constants with their literal values in the compiled code, so no storage is used. Immutables are stored in the contract's code section but accessed via special instructions, reducing gas costs. This difference affects how contracts behave and optimize gas.

Result

You understand the low-level differences that impact performance and security.

Knowing internal handling helps debug subtle bugs and optimize contract deployment.

Under the Hood

Constants are replaced by their literal values during compilation, so they do not occupy storage slots in the blockchain. Immutables are stored in a special area of the contract's bytecode called the code section, which is cheaper to read than regular storage. When the contract runs, the Ethereum Virtual Machine (EVM) accesses immutables via special opcodes that fetch these fixed values efficiently. This design reduces gas costs and prevents changes after deployment.

Why designed this way?

Constants were introduced to embed fixed values directly in code, saving storage and gas. Immutables were added later to allow one-time initialization of variables that depend on deployment parameters, combining flexibility with immutability. This design balances efficiency, security, and usability, avoiding the high gas cost of mutable storage while allowing some dynamic setup.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│   Source      │       │  Compiler     │       │   EVM         │
│   Code       │──────▶│ Replaces      │──────▶│ Executes with │
│ const MAX=5  │       │ constants     │       │ embedded const│
│ immutable x  │       │ embeds values │       │ and immutables│
└───────────────┘       └───────────────┘       └───────────────┘
                                │                       ▲
                                ▼                       │
                      ┌─────────────────┐       ┌───────────────┐
                      │ Immutables stored│────▶│ Special EVM   │
                      │ in code section  │     │ opcodes fetch │
                      └─────────────────┘       └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Can immutables be changed after contract deployment? Commit to yes or no.

Common Belief: Immutables can be changed anytime like normal variables.

Reality: Immutables can only be set once during contract creation and cannot be changed afterward.

Why it matters: Believing immutables are mutable leads to security flaws and incorrect assumptions about contract behavior.

Quick: Are constants stored in blockchain storage? Commit to yes or no.

Common Belief: Constants use storage slots like normal variables.

Reality: Constants are embedded directly in the bytecode and do not use storage slots.

Why it matters: Thinking constants use storage can cause confusion about gas costs and contract size.

Quick: Do constants and immutables always save gas compared to variables? Commit to yes or no.

Common Belief: Using constants and immutables always reduces gas costs in every situation.

Reality: While they often save gas, improper use or complex expressions can negate savings or increase deployment cost.

Why it matters: Assuming automatic gas savings can lead to inefficient contract design and unexpected costs.

Quick: Can you assign a constant value inside a constructor? Commit to yes or no.

Common Belief: Constants can be assigned or changed inside constructors.

Reality: Constants must be assigned at declaration and cannot be changed later, including in constructors.

Why it matters: Misunderstanding this causes compilation errors and wasted development time.

Expert Zone

1

Immutables are stored in the contract's code section, which is cheaper to access than storage but more expensive than pure constants embedded in bytecode.

2

Using complex expressions for constants can increase bytecode size, affecting deployment cost and contract size limits.

3

Stacking immutables and constants strategically can optimize gas usage for both deployment and runtime.

When NOT to use

Avoid constants and immutables when values need to change after deployment or depend on external data. Use regular storage variables or upgradeable contract patterns instead.

Production Patterns

In production, constants store fixed parameters like token decimals or max supply, while immutables store deployment-specific data like owner addresses or initial configuration. This pattern improves security and reduces gas costs in widely used token and governance contracts.

Connections

Functional Programming Immutability

Builds-on

Understanding immutability in blockchain helps grasp how functional programming avoids side effects by never changing data after creation.

Hardware Read-Only Memory (ROM)

Same pattern

Constants in smart contracts are like ROM in hardware: fixed data embedded at build time that cannot be altered, ensuring reliability.

Legal Contracts and Clauses

Analogy in different domain

Constants and immutables resemble fixed clauses in legal contracts that cannot be changed once signed, ensuring trust and clarity.

Common Pitfalls

#1 Trying to assign a constant value inside the constructor.

Wrong approach:

contract Example {
uint256 public constant MAX = 0;
constructor() {
MAX = 100; // wrong: constants cannot be assigned here
}
}

Correct approach:

contract Example {
uint256 public constant MAX = 100;
constructor() {
// no assignment needed
}
}

Root cause:

Misunderstanding that constants must be assigned at declaration and cannot be changed later.

#2 Using mutable variables when values should never change.

Wrong approach:

contract Example {
address public owner;
constructor(address _owner) {
owner = _owner;
}
function changeOwner(address newOwner) public {
owner = newOwner; // allows unwanted changes
}
}

Correct approach:

contract Example {
address public immutable owner;
constructor(address _owner) {
owner = _owner;
}
// no function to change owner
}

Root cause:

Not using immutables to enforce one-time assignment and prevent later changes.

#3 Declaring constants with lowercase names and unclear naming.

Wrong approach:

contract Example {
uint256 public constant maxSupply = 1000;
}

Correct approach:

contract Example {
uint256 public constant MAX_SUPPLY = 1000;
}

Root cause:

Ignoring naming conventions that improve code readability and maintainability.

Key Takeaways

Constants and immutables are special variables that cannot change after being set, improving contract safety and efficiency.

Constants are fixed at compile time and embedded in bytecode, while immutables are set once during deployment and stored efficiently.

Using constants and immutables reduces gas costs by avoiding expensive storage operations.

Proper use of these variables prevents bugs and security risks caused by unintended changes to critical data.

Understanding their syntax, behavior, and internal handling is key to writing robust and optimized smart contracts.