Packing variables for gas savings in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the gas cost difference when packing variables?

Consider the following two Solidity structs. Which one will generally consume less gas when stored on-chain?

struct A {
    uint256 a;
    uint256 b;
    bool c;
}

struct B {
    uint128 a;
    uint128 b;
    bool c;
}

A Struct A uses less gas because uint256 variables are native size and faster to access.

B Both structs use the same gas because bool is stored separately regardless of packing.

C Struct A uses less gas because bool variables increase storage slots in struct B.

D Struct B uses less gas because smaller variables are packed into fewer storage slots.

💡 Hint

Think about how Solidity packs variables into 32-byte storage slots.

Solidity packs smaller variables together to fit into a single 32-byte storage slot. Struct B uses uint128 and bool, which can be packed tightly, reducing storage slots and gas costs. Struct A uses two uint256 variables which each take a full slot, wasting space.

❓ Predict Output

intermediate

How many storage slots does this struct use?

Given this Solidity struct, how many 32-byte storage slots will it occupy?

struct Data {
    uint8 a;
    uint16 b;
    uint256 c;
    bool d;
}

A 1 storage slot

B 2 storage slots

C 3 storage slots

D 4 storage slots

💡 Hint

Remember that Solidity packs variables tightly if they fit in the same 32-byte slot.

uint8 a (1 byte) and uint16 b (2 bytes) pack into slot 0. uint256 c (32 bytes) uses slot 1. bool d (1 byte) uses slot 2. Total: 3 slots.

🔧 Debug

advanced

Why does this packed struct cause unexpected gas usage?

Analyze the following Solidity code snippet. Why does the gas cost remain high despite packing variables?

struct Packed {
    uint128 a;
    uint256 b;
    uint128 c;
}

A Because uint256 b breaks the packing, causing each uint128 to use separate slots.

B Because uint128 variables cannot be packed with uint256 variables in the same struct.

C Because bool variables are missing, packing is ineffective.

D Because the compiler ignores packing for structs with mixed variable sizes.

💡 Hint

Consider how storage slots are allocated in order.

uint256 b occupies a full 32-byte slot, so the uint128 variables before and after it cannot be packed together. This causes inefficient storage and higher gas.

🧠 Conceptual

advanced

What is the best order to pack these variables for minimal gas?

You have these variables to store in a struct: uint64 x;, bool y;, uint256 z;, uint32 w;. What order should you declare them to minimize gas?

A Declare <code>x</code>, <code>w</code>, <code>y</code> first, then <code>z</code> last.

B Declare <code>z</code> first, then <code>x</code>, <code>w</code>, and <code>y</code> last.

C Declare <code>y</code>, <code>z</code>, <code>x</code>, <code>w</code> in that order.

D Declare <code>w</code>, <code>x</code>, <code>z</code>, <code>y</code> in that order.

💡 Hint

Group smaller variables together before larger ones.

Smaller variables (uint64, uint32, bool) should be declared first to be packed into one slot. The large uint256 should be last to occupy its own slot.

❓ Predict Output

expert

What is the output of this Solidity storage slot calculation?

Given this Solidity contract snippet, what is the value of slot after execution?

contract Test {
    struct S {
        uint128 a;
        uint128 b;
        uint256 c;
    }
    S public s;
    function getSlot() public pure returns (uint) {
        uint slot;
        assembly {
            slot := s.slot
        }
        return slot;
    }
}

A 1

B 0

C Slot number depends on compiler version and cannot be determined.

D Compilation error due to invalid assembly.

💡 Hint

State variables are assigned storage slots starting from 0 in order.

The struct s is the first state variable, so its storage slot is 0. The assembly code correctly reads s.slot which is 0.