Gas optimization for L2 in Blockchain / Solidity - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a fixed-size array to save gas on L2.

Blockchain / Solidity

uint256[[1]] public fixedArray;

Drag options to blanks, or click blank then click option'

A0

B10

Cdynamic

Duint256

Attempts:

3 left

💡 Hint

Common Mistakes

Using dynamic arrays which cost more gas.

Setting size to zero which is invalid.

Using a fixed-size array like uint256[10] helps save gas on L2 by avoiding dynamic array overhead.

2fill in blank

medium

Complete the code to use calldata for function parameters to save gas on L2.

Blockchain / Solidity

function processData(string[1] data) external {}

Drag options to blanks, or click blank then click option'

A memory

B storage

C calldata

D public

Attempts:

3 left

💡 Hint

Common Mistakes

Using memory which copies data and costs more gas.

Using storage which is not allowed for function parameters.

Using calldata for external function parameters saves gas because it avoids copying data into memory.

3fill in blank

hard

Fix the error in the code to optimize gas by packing variables.

Blockchain / Solidity

contract GasSaver {
    uint128 public a;
    uint[1] public b;
}

Drag options to blanks, or click blank then click option'

A128

B256

C64

D32

Attempts:

3 left

💡 Hint

Common Mistakes

Using uint256 which wastes storage slots.

Using different sizes that prevent packing.

Using uint128 for both variables allows Solidity to pack them into one storage slot, saving gas.

4fill in blank

hard

Fill both blanks to optimize gas by using unchecked math and short-circuiting.

Blockchain / Solidity

function increment(uint256 x) public pure returns (uint256) {
    uint256 y = unchecked { x [1] 1 };
    return y [2] 0 ? y : 0;
}

Drag options to blanks, or click blank then click option'

A+

B>

C<

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction which may cause underflow.

Using wrong comparison operators that break logic.

Using unchecked with + avoids overflow checks, saving gas. The comparison y > 0 short-circuits unnecessary operations.

5fill in blank

hard

Fill all three blanks to optimize gas by using short-circuit evaluation, minimal storage writes, and efficient loops.

Blockchain / Solidity

function sum(uint256[] memory data) public pure returns (uint256) {
    uint256 total = 0;
    for (uint256 i = 0; i [1] data.length; i++) {
        if (data[i] [2] 0) {
            total [3]= data[i];
        }
    }
    return total;
}

Drag options to blanks, or click blank then click option'

A<=

B>

C+

D-

E<

Attempts:

3 left

💡 Hint

Common Mistakes

Using <= in loop condition causing out-of-bounds.

Adding zero values wasting gas.

Using -= instead of += causing wrong results.

Using i < data.length avoids out-of-bounds errors. Checking data[i] > 0 skips zero values to save gas. Using += efficiently accumulates the sum.

Practice

1. Which of the following is a common method to reduce gas costs on Layer 2 blockchains?

easy

A. Using loops with many iterations

B. Increasing the block size limit

C. Adding more storage variables to the contract

D. Using calldata instead of memory for function inputs

Solution

1. Step 1: Understand calldata vs memory

   Calldata is cheaper than memory because it is read-only and does not require copying data.

2. Step 2: Identify gas saving method

   Using calldata for function inputs reduces gas compared to memory or storage.

3. Final Answer:

   Using calldata instead of memory for function inputs -> Option D

4. Quick Check:

   Calldata is cheaper than memory [OK]

Hint: Choose calldata for inputs to save gas on L2 [OK]

Common Mistakes:

• Thinking increasing block size reduces gas
• Assuming more storage variables save gas
• Using loops without optimization

2. Which Solidity syntax correctly declares a function parameter to use calldata for gas optimization on L2?

easy

A. function foo(string memory data) external {}

B. function foo(string calldata data) external {}

C. function foo(string storage data) external {}

D. function foo(string data) external {}

Solution

1. Step 1: Recall parameter data location keywords

   Solidity allows memory, storage, or calldata for reference types in parameters.

2. Step 2: Identify calldata usage

   Calldata is specified explicitly as string calldata for external functions to save gas.

3. Final Answer:

   function foo(string calldata data) external {} -> Option B

4. Quick Check:

   Calldata keyword used correctly [OK]

Hint: Use 'calldata' keyword for external function parameters [OK]

Common Mistakes:

• Using memory instead of calldata for external inputs
• Omitting data location keyword
• Using storage incorrectly in parameters

3. What will be the gas cost difference when using unchecked math in Solidity on L2 compared to normal math?

medium

A. Gas cost decreases because overflow checks are skipped

B. Gas cost increases due to extra checks

C. Gas cost stays the same

D. Gas cost is unpredictable

Solution

1. Step 1: Understand unchecked math

   Unchecked math skips overflow and underflow checks, saving gas.

2. Step 2: Compare gas costs

   Skipping checks reduces gas cost compared to normal safe math operations.

3. Final Answer:

   Gas cost decreases because overflow checks are skipped -> Option A

4. Quick Check:

   Unchecked math saves gas by skipping checks [OK]

Hint: Unchecked math skips checks, lowering gas [OK]

Common Mistakes:

• Assuming unchecked math adds overhead
• Believing gas cost is unchanged
• Ignoring overflow risks

4. Given this Solidity snippet on L2, what is the main issue causing higher gas usage?

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

medium

A. Missing unchecked block for increment

B. Using public variable instead of private

C. Function should be view instead of external

D. No issue, code is optimal

Solution

1. Step 1: Identify gas cost in arithmetic

   Normal addition includes overflow checks increasing gas.

2. Step 2: Suggest unchecked usage

   Wrapping increment in unchecked { count += 1; } saves gas by skipping checks.

3. Final Answer:

   Missing unchecked block for increment -> Option A

4. Quick Check:

   Unchecked block reduces gas for safe increments [OK]

Hint: Use unchecked for simple increments to save gas [OK]

Common Mistakes:

• Thinking public visibility affects gas here
• Confusing external with view function
• Assuming code is already optimized

5. You want to optimize a Layer 2 contract that stores multiple small variables. Which approach best reduces gas usage?

hard

A. Use dynamic arrays for all variables

B. Store each variable in separate storage slots for clarity

C. Pack multiple uint8 variables into a single uint256 storage slot

D. Avoid using calldata and always copy to memory

Solution

1. Step 1: Understand storage slot packing

   Multiple small variables like uint8 can fit into one 256-bit slot, saving gas.

2. Step 2: Compare storage strategies

   Separating variables wastes slots; dynamic arrays add overhead; calldata usage unrelated here.

3. Final Answer:

   Pack multiple uint8 variables into a single uint256 storage slot -> Option C

4. Quick Check:

   Storage packing reduces gas by slot sharing [OK]

Hint: Pack small vars into one slot to save gas [OK]

Common Mistakes:

• Using separate slots wastes gas
• Overusing dynamic arrays increases cost
• Ignoring calldata benefits in storage