Packing variables for gas savings in Blockchain / Solidity - Deep Dive

Overview - Packing variables for gas savings

What is it?

Packing variables for gas savings is a technique used in blockchain smart contract programming to reduce the amount of gas (transaction fee) needed by storing multiple small variables efficiently in a single storage slot. Since blockchain storage is expensive, combining variables that use less than 32 bytes into one slot saves space and gas. This method helps smart contracts run cheaper and faster by minimizing storage costs.

Why it matters

Without packing variables, smart contracts waste storage space by placing each variable in its own 32-byte slot, leading to higher gas fees for users. This makes deploying and interacting with contracts more expensive and less accessible. Efficient packing lowers costs, making blockchain applications more affordable and scalable, which is crucial for widespread adoption and user satisfaction.

Where it fits

Before learning packing variables, you should understand how blockchain storage works and the concept of gas fees. After mastering packing, you can explore advanced gas optimization techniques and smart contract security practices to write efficient and safe contracts.

Mental Model

Core Idea

Packing variables means fitting multiple small pieces of data tightly into one storage slot to save space and reduce gas costs.

Think of it like...

It's like packing a suitcase efficiently by folding and stacking clothes tightly instead of throwing each item separately, so you use less space and carry less weight.

┌───────────────────────────────┐
│ Storage Slot (32 bytes)       │
│ ┌───────┬───────┬───────┬───┐ │
│ │ var1  │ var2  │ var3  │...│ │
│ │(8b)   │(8b)   │(16b)  │   │ │
│ └───────┴───────┴───────┴───┘ │
└───────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Blockchain Storage Slots

Concept: Learn that blockchain stores data in fixed-size 32-byte slots and each variable usually occupies one slot.

In Ethereum and similar blockchains, smart contract storage is divided into slots of 32 bytes (256 bits). Each variable you declare typically uses one slot, even if it needs less space. For example, a boolean or uint8 still uses a full 32-byte slot by default.

Result

Each variable consumes a full 32-byte slot, leading to potential waste if variables are small.

Understanding the fixed slot size is key to realizing why packing variables can save gas.

2

Foundation

Gas Costs Linked to Storage Usage

Concept: Gas fees increase with the amount of storage used, so reducing storage slots lowers gas costs.

Every time a smart contract writes to storage, it costs gas proportional to the number of slots used. Writing to a new slot costs more gas than updating an existing one. Therefore, minimizing the number of slots used by packing variables reduces transaction fees.

Result

More storage slots mean higher gas fees; fewer slots mean cheaper transactions.

Knowing that storage size directly affects gas costs motivates efficient variable packing.

3

Intermediate

Packing Small Variables Together

🤔Before reading on: do you think two uint8 variables use one or two storage slots? Commit to your answer.

Concept: Multiple small variables can be combined into a single 32-byte slot if their total size fits within 32 bytes.

Variables like uint8 (1 byte) or bool (1 byte) can be declared consecutively so the compiler packs them into one slot. For example, four uint8 variables can fit into one 32-byte slot because 4 bytes < 32 bytes. This reduces the number of slots used.

Result

Multiple small variables share one storage slot, saving space and gas.

Understanding how the compiler packs variables helps write contracts that use less gas.

4

Intermediate

Order of Declaration Affects Packing

🤔Before reading on: do you think the order of variables affects how they are packed? Commit to yes or no.

Concept: The order in which variables are declared affects how the compiler packs them into slots.

Solidity packs variables tightly only if they are declared consecutively and their sizes fit together. Declaring a large variable between small ones breaks packing. For example, placing a uint256 between uint8 variables forces separate slots, increasing gas.

Result

Proper ordering leads to better packing and lower gas; poor ordering wastes space.

Knowing that declaration order impacts packing helps avoid costly mistakes.

5

Intermediate

Using Fixed-Size Types for Efficient Packing

Concept: Choosing smaller fixed-size types like uint8 or bool instead of larger types helps packing multiple variables in one slot.

Using smaller types reduces the size each variable occupies. For example, using uint8 instead of uint256 for small numbers allows multiple variables to fit in one slot. This is a common practice to optimize gas usage.

Result

Smaller types enable more variables per slot, reducing storage and gas costs.

Selecting appropriate variable types is a simple yet powerful gas optimization technique.

6

Advanced

Packing Structs and Arrays for Gas Savings

🤔Before reading on: do you think arrays and structs pack variables automatically? Commit to yes or no.

Concept: Structs and arrays can also benefit from packing if their members are ordered and typed properly.

Struct members are packed similarly to standalone variables if declared consecutively with compatible sizes. Arrays of small types pack each element in separate slots, but fixed-size arrays can be optimized by packing elements. Understanding this helps optimize complex data structures.

Result

Well-designed structs and arrays reduce storage slots and gas fees.

Knowing how packing applies to complex types unlocks deeper gas savings.

7

Expert

Compiler Behavior and Packing Limitations

🤔Before reading on: do you think the compiler always packs variables optimally? Commit to yes or no.

Concept: The compiler tries to pack variables but has limitations and rules that affect packing efficiency.

Solidity packs variables within the same storage slot only if they are declared consecutively and fit together. Variables declared in different contracts or inherited contracts may not pack together. Also, dynamic types and mappings do not pack. Understanding these rules helps avoid surprises and write better contracts.

Result

Knowing compiler packing rules prevents inefficient storage layouts and unexpected gas costs.

Understanding compiler internals and limitations is crucial for expert-level gas optimization.

Under the Hood

At runtime, the Ethereum Virtual Machine (EVM) stores contract variables in 32-byte storage slots. When variables are declared, the Solidity compiler assigns them to these slots. For small variables, the compiler attempts to pack multiple into one slot by placing their bits side by side, starting from the least significant bits. This reduces the number of storage slots used, lowering gas costs since each slot write is expensive. However, packing only happens for consecutive variables of fixed size and known length. Dynamic types and variables declared separately are stored in separate slots.

Why designed this way?

The 32-byte slot size matches the EVM's word size, optimizing read/write operations. Packing variables reduces storage costs without changing the EVM architecture. This design balances simplicity and efficiency. Alternatives like variable-length slots would complicate the EVM and increase execution costs. Packing is a compiler-level optimization that leverages fixed slot size while minimizing gas fees.

┌───────────────┐
│ Storage Slot  │
│ 32 bytes (256b)│
│ ┌───────────┐ │
│ │ var1 (8b) │ │
│ ├───────────┤ │
│ │ var2 (8b) │ │
│ ├───────────┤ │
│ │ var3 (16b)│ │
│ └───────────┘ │
└───────────────┘
Compiler packs bits side-by-side in one slot if total ≤ 32 bytes.

Myth Busters - 4 Common Misconceptions

Quick: Does declaring variables of the same type far apart still pack them together? Commit to yes or no.

Common Belief: Variables of the same type always pack together regardless of declaration order.

Reality: Only consecutive variables declared together pack; separated declarations do not pack and use separate slots.

Why it matters: Assuming automatic packing leads to unexpected high gas costs due to wasted storage slots.

Quick: Does using smaller types always reduce gas costs? Commit to yes or no.

Common Belief: Using smaller types like uint8 always saves gas compared to uint256.

Reality: Smaller types save gas only when packed properly; if declared poorly, they may use full slots and cost the same or more.

Why it matters: Misusing small types without packing can increase complexity without gas savings.

Quick: Are dynamic types like strings and mappings packed with other variables? Commit to yes or no.

Common Belief: Dynamic types pack with other variables to save gas.

Reality: Dynamic types are stored separately and do not pack with fixed-size variables.

Why it matters: Expecting packing with dynamic types causes confusion and inefficient storage design.

Quick: Does the compiler always optimize packing perfectly? Commit to yes or no.

Common Belief: The compiler always finds the best packing arrangement automatically.

Reality: The compiler packs only based on declaration order and type sizes; manual ordering is needed for best results.

Why it matters: Relying on the compiler alone can miss gas savings opportunities.

Expert Zone

1

Packing variables across inherited contracts does not happen automatically; each contract's storage layout is separate.

2

Using custom types or enums affects packing because their underlying size determines how they fit in slots.

3

Storage slot alignment matters: variables crossing slot boundaries cause partial packing and wasted space.

When NOT to use

Packing is not suitable when variables need to be updated independently very often, as packing can increase gas for updates due to read-modify-write cycles. Also, dynamic types and mappings cannot be packed; alternative optimizations like caching or off-chain storage should be considered.

Production Patterns

In production, developers carefully order variables by size and type to maximize packing. Structs are designed with packing in mind, placing smaller members first. Tools like Solidity's storage layout visualizers help audit packing. Gas savings from packing are critical in high-frequency contracts like DeFi protocols and NFT minting.

Connections

Data Compression

Packing variables is a form of data compression applied at the storage level.

Understanding packing as compression helps appreciate how reducing data size saves resources, similar to compressing files to save disk space.

Memory Alignment in Systems Programming

Both involve organizing data to fit efficiently in fixed-size blocks for performance and space savings.

Knowing memory alignment concepts clarifies why variable order and size affect packing efficiency in smart contracts.

Logistics and Container Loading

Packing variables is like loading items into containers to maximize space usage and minimize cost.

Recognizing this connection highlights the universal challenge of efficient resource use across fields.

Common Pitfalls

#1 Declaring variables in random order causing poor packing.

Wrong approach:

uint8 smallNumber1;
uint256 bigNumber;
uint8 smallNumber2;
bool flag;

Correct approach:

uint8 smallNumber1;
uint8 smallNumber2;
bool flag;
uint256 bigNumber;

Root cause:

Not understanding that declaration order affects how variables are packed into storage slots.

#2 Using dynamic types expecting them to pack with fixed-size variables.

Wrong approach:

uint8 age;
string name;
bool isActive;

Correct approach:

uint8 age;
bool isActive;
string name; // placed after fixed-size variables

Root cause:

Misunderstanding that dynamic types are stored separately and do not pack with fixed-size variables.

#3 Assuming smaller types always reduce gas without packing.

Wrong approach:

uint8 a;
uint256 b;
uint8 c;

Correct approach:

uint8 a;
uint8 c;
uint256 b;

Root cause:

Not realizing that small variables separated by large ones cannot be packed together, negating gas savings.

Key Takeaways

Blockchain storage uses fixed 32-byte slots, so small variables can waste space if not packed.

Packing variables tightly in one slot reduces gas fees by minimizing storage usage.

Declaration order and variable size critically affect how well variables pack together.

Dynamic types and mappings do not pack with fixed-size variables and require separate storage.

Expert-level packing requires understanding compiler behavior, inheritance, and storage layout rules.