Packing variables for gas savings in Blockchain / Solidity - Mini Project: Build & Apply

Packing variables for gas savings

📖 Scenario: You are creating a smart contract on Ethereum. You want to store user data efficiently to save gas fees when users interact with your contract.

🎯 Goal: Build a Solidity contract that packs multiple small variables into a single storage slot to reduce gas costs.

📋 What You'll Learn

Create a Solidity contract named UserData

Declare three variables: uint8 age, bool isMember, and uint16 score

Pack these variables into a single uint256 storage variable named packedData

Write a function packData(uint8 age, bool isMember, uint16 score) to store the packed data

Write a function unpackData() that returns the original age, isMember, and score

💡 Why This Matters

🌍 Real World

Packing variables reduces the amount of storage used in smart contracts, which lowers gas fees for users interacting with the contract.

💼 Career

Understanding gas optimization techniques like variable packing is important for blockchain developers to write efficient and cost-effective smart contracts.

1

Create the contract and declare variables

Create a Solidity contract named UserData and declare three state variables: uint8 age, bool isMember, and uint16 score.

Blockchain / Solidity

contract UserData {
    // Declare variables here
}

Hint

Use contract UserData { } to start. Declare each variable inside the contract.

2

Add a packed storage variable

Inside the UserData contract, declare a single uint256 state variable named packedData to hold all packed values.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract UserData {
    uint8 age;
    bool isMember;
    uint16 score;
    // Declare packedData here
}

Hint

Use uint256 packedData; inside the contract.

3

Write the packData function

Write a public function packData(uint8 age, bool isMember, uint16 score) that packs the three variables into packedData using bit shifting and bitwise OR operations.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract UserData {
    uint8 age;
    bool isMember;
    uint16 score;
    uint256 packedData;

    // Write packData function here
}

Hint

Use bit shifting: age at bits 0-7, isMember at bit 8, score at bits 9-24.

4

Write the unpackData function and print results

Write a public view function unpackData() that returns age, isMember, and score by extracting them from packedData using bitwise operations. Then, add a function printData() that returns a string showing the unpacked values.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract UserData {
    uint8 age;
    bool isMember;
    uint16 score;
    uint256 packedData;

    function packData(uint8 _age, bool _isMember, uint16 _score) public {
        packedData = uint256(_age);
        packedData |= (uint256(_isMember ? 1 : 0) << 8);
        packedData |= (uint256(_score) << 9);
    }

    // Write unpackData and printData functions here
}

Hint

Use bit masks and shifts to extract each value. Use a helper function to convert numbers to strings for printing.

Practice

1.

What is the main benefit of packing variables in blockchain smart contracts?

easy

A. It makes the code run faster on the CPU

B. It reduces gas costs by using fewer storage slots

C. It increases the contract's storage size

D. It improves the contract's security automatically

Solution

1. Step 1: Understand storage slots in blockchain

   Each storage slot costs gas. Packing variables reduces the number of slots used.

2. Step 2: Effect of packing variables

   By grouping smaller variables into one slot, gas usage decreases because fewer slots are needed.

3. Final Answer:

   It reduces gas costs by using fewer storage slots -> Option B

4. Quick Check:

   Packing = Less gas [OK]

Hint: Packing saves gas by reducing storage slots used [OK]

Common Mistakes:

• Thinking packing speeds up CPU execution
• Believing packing increases storage size
• Assuming packing improves security automatically

2.

Which of the following Solidity variable declarations correctly packs two uint8 variables into one storage slot?

contract Example {
    uint8 a;
    uint8 b;
}

easy

A. Both a and b are declared consecutively as uint8

B. a is uint8 and b is uint256

C. a is uint256 and b is uint8

D. Both a and b are declared as uint256

Solution

1. Step 1: Check variable types for packing

   Variables of the same small type declared consecutively can be packed into one slot.

2. Step 2: Analyze given declarations

   Both a and b are uint8, so they fit together in one 256-bit slot.

3. Final Answer:

   Both a and b are declared consecutively as uint8 -> Option A

4. Quick Check:

   Same small types together = packed [OK]

Hint: Use same small types consecutively to pack [OK]

Common Mistakes:

• Mixing large and small types breaks packing
• Declaring variables far apart prevents packing
• Assuming different types pack automatically

3.

Consider this Solidity contract snippet:

contract Test {
    uint128 a = 1;
    uint64 b = 2;
    uint64 c = 3;
}

How many storage slots does this contract use for these variables?

medium

A. 1 storage slot

B. 3 storage slots

C. 2 storage slots

D. 4 storage slots

Solution

1. Step 1: Calculate sizes of variables

   a is 128 bits, b and c are 64 bits each.

2. Step 2: Pack variables into 256-bit slots

   a (128 bits) starts the slot, b and c (64+64=128 bits) fit exactly in the remaining space of the same slot.

3. Final Answer:

   1 storage slot -> Option A

4. Quick Check:

   128 + 64 + 64 = 256 bits = 1 slot [OK]

Hint: Sum consecutive vars' bits: 128+64+64=256 -> 1 slot [OK]

Common Mistakes:

• Counting each variable as one slot
• Ignoring packing into remaining space after uint128
• Assuming different sizes cannot pack together

4.

Identify the error in this Solidity contract that tries to pack variables for gas savings:

contract Faulty {
    uint256 a;
    uint8 b;
    uint256 d;
    uint8 c;
}

medium

A. Variables b and c must be declared before a

B. Variables a and d should be uint8 to pack

C. All variables are packed correctly without error

D. Variables b and c cannot be packed because d breaks the sequence

Solution

1. Step 1: Understand packing order

   Packing works best when small variables are declared consecutively without large variables interrupting.

2. Step 2: Analyze variable order

   b and c are small but separated by large a and d, so they cannot be packed together.

3. Final Answer:

   Variables b and c cannot be packed because d breaks the sequence -> Option D

4. Quick Check:

   Interrupting large vars break packing [OK]

Hint: Keep small vars together without large vars interrupting [OK]

Common Mistakes:

• Assuming all small vars pack regardless of order
• Changing types unnecessarily
• Thinking order does not affect packing

5.

You want to optimize this Solidity struct for gas savings by packing variables:

struct Data {
    uint8 flag;
    uint256 id;
    uint16 count;
    uint8 status;
}

Which rearrangement packs variables best into the fewest storage slots?

hard

A. struct Data {
uint8 flag;
uint256 id;
uint16 count;
uint8 status;
}

B. struct Data {
uint16 count;
uint256 id;
uint8 flag;
uint8 status;
}

C. struct Data {
uint8 flag;
uint8 status;
uint16 count;
uint256 id;
}

D. struct Data {
uint8 flag;
uint16 count;
uint256 id;
uint8 status;
}

Solution

1. Step 1: Order variables from smallest to largest

   Place small variables (uint8, uint16) together first to pack tightly.

2. Step 2: Place largest variable last

   uint256 id is largest and should be last to avoid breaking packing of smaller vars.

3. Final Answer:

   struct Data { uint8 flag; uint8 status; uint16 count; uint256 id; } -> Option C

4. Quick Check:

   Small vars first, large last = best packing [OK]

Hint: Put small vars first, big vars last for best packing [OK]

Common Mistakes:

• Placing large vars before small ones
• Mixing variable sizes without order
• Ignoring packing benefits in structs