Gas optimization for L2 in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Gas cost difference between storage and memory

Consider the following Solidity function on an L2 chain. What is the main difference in gas cost when using storage vs memory for the array?

Blockchain / Solidity

pragma solidity ^0.8.19;

contract GasTest {
    uint[] public data;

    function storeData(uint[] calldata input) external {
        for (uint i = 0; i < input.length; i++) {
            data.push(input[i]);
        }
    }

    function processData() external view returns (uint sum) {
        uint[] storage arr = data;
        for (uint i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
    }

    function processDataMemory() external view returns (uint sum) {
        uint[] memory arr = data;
        for (uint i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
    }
}

A Both <code>storage</code> and <code>memory</code> have the same gas cost on L2 because storage reads are free.

B Using <code>memory</code> copies the entire array from storage to memory, increasing gas cost due to data copying on L2.

C Using <code>storage</code> for the array reads directly from blockchain storage, which is cheaper on L2 than copying to <code>memory</code>.

D Using <code>memory</code> is cheaper because it avoids storage reads, which are very expensive on L2.

💡 Hint

Think about what happens when you copy data from storage to memory on L2.

On L2, reading from storage is cheaper than on L1 but still costs gas. Copying data from storage to memory requires reading each element and writing it to memory, which increases gas cost. Therefore, using memory for large arrays increases gas due to copying overhead.

❓ Predict Output

intermediate

Effect of calldata vs memory on gas usage

What is the gas cost difference when using calldata vs memory for function parameters on an L2 chain?

Blockchain / Solidity

pragma solidity ^0.8.19;

contract CalldataTest {
    function useCalldata(uint[] calldata input) external pure returns (uint) {
        uint sum = 0;
        for (uint i = 0; i < input.length; i++) {
            sum += input[i];
        }
        return sum;
    }

    function useMemory(uint[] memory input) external pure returns (uint) {
        uint sum = 0;
        for (uint i = 0; i < input.length; i++) {
            sum += input[i];
        }
        return sum;
    }
}

A Using <code>calldata</code> is more expensive because it requires decoding data on each access.

B Using <code>memory</code> is cheaper because it allows faster access to data on L2.

C Both <code>calldata</code> and <code>memory</code> cost the same gas on L2.

D Using <code>calldata</code> is cheaper because it avoids copying data into memory on L2.

💡 Hint

Consider how calldata is handled differently from memory in Solidity.

calldata is a read-only area where function arguments are stored. Using calldata avoids copying data into memory, saving gas on L2. memory requires copying, which costs more gas.

🔧 Debug

advanced

Unexpected high gas cost in loop with storage writes

Why does the following Solidity function consume unexpectedly high gas on an L2 chain?

Blockchain / Solidity

pragma solidity ^0.8.19;

contract LoopGas {
    mapping(uint => uint) public data;

    function updateData(uint n) external {
        for (uint i = 0; i < n; i++) {
            data[i] = i * 2;
        }
    }
}

A Because each storage write inside the loop costs gas, and writing to storage is expensive even on L2.

B Because the loop variable <code>i</code> is not declared as <code>uint256</code>, causing overflow errors.

C Because the mapping <code>data</code> is not initialized, causing runtime errors.

D Because the function lacks the <code>payable</code> modifier, causing gas to be refunded.

💡 Hint

Think about the cost of writing to storage repeatedly in a loop on L2.

Each write to storage costs gas, even on L2. Writing inside a loop multiplies this cost by the number of iterations, causing high gas consumption.

📝 Syntax

advanced

Correct syntax for unchecked arithmetic to save gas

Which option correctly uses unchecked to save gas on L2 by skipping overflow checks?

Blockchain / Solidity

pragma solidity ^0.8.19;

contract UncheckedExample {
    function sum(uint a, uint b) external pure returns (uint) {
        uint c;
        // Insert unchecked block here
        return c;
    }
}

A { unchecked c = a + b; }

B unchecked c = a + b;

C unchecked { c = a + b; }

D c = unchecked(a + b);

💡 Hint

Recall the correct syntax for the unchecked block in Solidity.

The unchecked keyword is used as a block to wrap code where overflow checks are skipped. The correct syntax is unchecked { ... }.

🚀 Application

expert

Optimizing batch token transfers on L2

You want to optimize a batch token transfer function on an L2 chain to minimize gas. Which approach will reduce gas the most?

A Use a single <code>transferFrom</code> call for the total amount, then update balances in memory and write once to storage.

B Use <code>delegatecall</code> to an external contract for each transfer to save gas.

C Use multiple <code>transferFrom</code> calls but mark the function <code>payable</code> to get gas refunds.

D Use a single <code>transferFrom</code> call per recipient inside a loop, writing to storage each time.

💡 Hint

Think about minimizing storage writes and external calls on L2.

Minimizing storage writes is key for gas savings on L2. Doing all balance updates in memory and writing once reduces gas. Multiple transferFrom calls and storage writes increase gas cost.