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.