Solidity compiler optimization in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Effect of optimizer on gas usage

Consider the following Solidity contract compiled with and without optimization enabled. What is the expected difference in gas cost when calling increment()?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Counter {
    uint256 public count;

    function increment() public {
        count += 1;
    }
}

A There is no difference in gas usage between optimized and non-optimized versions.

B The optimized version uses more gas because it adds extra checks.

C The optimized version uses less gas because it reduces redundant instructions.

D The non-optimized version uses less gas because it has simpler bytecode.

💡 Hint

Think about how compiler optimization removes unnecessary steps.

Enabling optimization allows the compiler to reduce redundant instructions and improve bytecode efficiency, which lowers gas consumption when calling functions like increment().

🧠 Conceptual

intermediate

Understanding optimizer runs parameter

What does increasing the runs parameter in Solidity compiler optimization do?

A It instructs the optimizer to optimize for more frequent function calls, reducing runtime gas cost at the expense of deployment size.

B It tells the optimizer to focus on reducing deployment size over runtime gas cost.

C It disables optimization for constructor functions only.

D It increases the number of compiler warnings during compilation.

💡 Hint

Think about what 'runs' means in terms of how often functions are called.

The runs parameter guides the optimizer to balance between deployment size and runtime gas cost. Higher runs mean optimizing for frequent calls, which may increase deployment size but reduce gas cost per call.

🔧 Debug

advanced

Identify the cause of increased gas after optimization

A developer notices that after enabling optimization, a contract's transfer function uses more gas than before. What is the most likely cause?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Token {
    mapping(address => uint256) balances;

    function transfer(address to, uint256 amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        unchecked {
            balances[msg.sender] -= amount;
            balances[to] += amount;
        }
    }
}

A The optimizer adds redundant events that increase gas cost.

B The optimizer removes the <code>unchecked</code> block, adding overflow checks and increasing gas.

C The optimizer changes storage layout, causing more expensive storage reads.

D The optimizer inlines the <code>require</code> statement, increasing bytecode size and gas.

💡 Hint

Consider what unchecked does and how optimization might affect it.

If the optimizer removes the unchecked block, Solidity adds overflow checks by default, which increases gas cost during arithmetic operations.

📝 Syntax

advanced

Which pragma enables optimizer with 200 runs?

Choose the correct Solidity pragma directive to enable optimizer with 200 runs.

A

pragma solidity ^0.8.0; // SPDX-License-Identifier: MIT
// solc optimizer runs=200 enabled=true

B pragma solidity ^0.8.0; optimizer: { enabled: true, runs: 200 };

C pragma solidity ^0.8.0; // optimizer runs=200 enabled=true

D pragma solidity ^0.8.0; // solc optimizer runs=200 enabled=true

💡 Hint

Remember pragma directives only specify compiler version; optimizer settings are usually in config files or comments.

Optimizer settings are not part of the pragma directive but are specified in config files or comments. Option A shows a valid comment format for SPDX and optimizer settings.

🚀 Application

expert

Predict gas savings from optimizer on complex contract

A complex contract has many small functions called frequently. The optimizer is enabled with 1000 runs. Which statement best describes the expected effect?

A Both deployment size and gas cost per call will decrease significantly.

B Deployment size will decrease significantly, but gas cost per call will increase.

C Neither deployment size nor gas cost per call will change noticeably.

D Gas cost per function call will decrease significantly, but deployment size will increase.

💡 Hint

Think about how high runs affect optimization trade-offs.

High runs value tells the optimizer to reduce runtime gas cost for frequently called functions, often increasing deployment size due to inlining and other optimizations.

Practice

1. What is the main purpose of enabling compiler optimization in Solidity?

easy

A. To reduce gas costs and improve contract efficiency

B. To add more features to the Solidity language

C. To make the contract code longer and more complex

D. To disable contract deployment on test networks

Solution

1. Step 1: Understand compiler optimization purpose

   Compiler optimization focuses on improving how the code runs, mainly by reducing gas usage.

2. Step 2: Identify the effect on contracts

   Optimized contracts use less gas and run more efficiently on the blockchain.

3. Final Answer:

   To reduce gas costs and improve contract efficiency -> Option A

4. Quick Check:

   Optimization = reduce gas and improve efficiency [OK]

Hint: Optimization saves gas by making code efficient [OK]

Common Mistakes:

• Thinking optimization adds new language features
• Believing optimization increases contract size
• Confusing optimization with deployment settings

2. Which of the following is the correct way to enable optimization when compiling a Solidity contract using solc?

easy

A. solc --optimize-runs Contract.sol

B. solc --no-optimize Contract.sol

C. solc --optimize-runs=off Contract.sol

D. solc --optimize --optimize-runs 200 Contract.sol

Solution

1. Step 1: Recall correct optimization flags

   The correct flags are --optimize to enable optimization and --optimize-runs to set optimization runs.

2. Step 2: Check each option for syntax correctness

   solc --optimize --optimize-runs 200 Contract.sol uses both flags correctly with a numeric value for runs; others are incorrect or incomplete.

3. Final Answer:

   solc --optimize --optimize-runs 200 Contract.sol -> Option D

4. Quick Check:

   Enable optimization with --optimize and runs number [OK]

Hint: Use both --optimize and --optimize-runs with a number [OK]

Common Mistakes:

• Omitting --optimize flag
• Using invalid or missing runs value
• Using incorrect flag syntax

3. Given the following Solidity code compiled with optimization enabled and runs set to 1, what is the expected effect on gas usage when calling increment() multiple times?

contract Counter {
    uint public count;
    function increment() public {
        count += 1;
    }
}

medium

A. Gas cost increases exponentially with each call

B. Lower gas cost per call optimized for many calls

C. Higher gas cost per call but optimized for fewer calls

D. No change in gas cost per call

Solution

1. Step 1: Understand optimize-runs parameter meaning

   Setting optimize-runs to 1 tells the compiler to optimize for fewer executions, making each call more expensive but overall smaller code.

2. Step 2: Analyze gas cost effect on repeated calls

   With runs=1, gas cost per call is higher, but contract size is smaller; optimized for few calls.

3. Final Answer:

   Higher gas cost per call but optimized for fewer calls -> Option C

4. Quick Check:

   optimize-runs=1 means optimize for fewer calls [OK]

Hint: Low optimize-runs means higher gas per call, fewer calls optimized [OK]

Common Mistakes:

• Assuming runs=1 optimizes for many calls
• Thinking gas cost stays the same
• Confusing contract size with gas cost

4. You compiled a Solidity contract with optimization enabled but noticed unexpected behavior during testing. Which of the following is the most likely cause?

medium

A. The contract was deployed on the wrong network

B. Optimization changed the logic causing subtle bugs

C. The Solidity version was too old to support optimization

D. The contract source code was missing comments

Solution

1. Step 1: Understand optimization effects on code

   Optimization can rearrange or simplify code, sometimes causing subtle logic changes or bugs.

2. Step 2: Identify likely cause of unexpected behavior

   Unexpected behavior after optimization usually means optimization affected logic; other options are unrelated.

3. Final Answer:

   Optimization changed the logic causing subtle bugs -> Option B

4. Quick Check:

   Optimization can cause subtle logic bugs [OK]

Hint: Test contracts carefully after enabling optimization [OK]

Common Mistakes:

• Blaming network deployment instead of optimization
• Ignoring compiler version compatibility
• Thinking comments affect optimization

5. You want to optimize a Solidity contract that will be called many times after deployment. Which compiler optimization setting should you choose to minimize total gas cost over many calls?

hard

A. Enable optimization with --optimize-runs set to a high number like 10000

B. Disable optimization to keep code simple

C. Enable optimization with --optimize-runs set to 1

D. Use no optimization flags and rely on manual gas saving

Solution

1. Step 1: Understand optimize-runs impact on gas cost

   High optimize-runs value tells the compiler to optimize for many executions, reducing gas cost per call.

2. Step 2: Choose setting for many calls

   Setting --optimize-runs to a high number like 10000 minimizes gas cost over many calls, best for frequently used contracts.

3. Final Answer:

   Enable optimization with --optimize-runs set to a high number like 10000 -> Option A

4. Quick Check:

   High optimize-runs = optimize for many calls [OK]

Hint: Use high optimize-runs for contracts called many times [OK]

Common Mistakes:

• Using low optimize-runs for frequently called contracts
• Disabling optimization thinking it saves gas
• Ignoring compiler optimization flags