Batch operations in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Ethereum batch transaction simulation?

Consider a batch operation that sends 3 transactions in sequence. Each transaction adds 10 to a shared counter starting at 0. What is the final counter value after all transactions succeed?

Blockchain / Solidity

let counter = 0;
const batch = [
  () => { counter += 10; return counter; },
  () => { counter += 10; return counter; },
  () => { counter += 10; return counter; }
];
for (const tx of batch) {
  tx();
}
console.log(counter);

A Error: counter is undefined

B 30

C 10

D 0

💡 Hint

Each transaction adds 10 to the counter. Think about how many times this happens.

The counter starts at 0. Each of the 3 transactions adds 10, so after all run, counter is 30.

🧠 Conceptual

intermediate

Which statement best describes batch operations in blockchain?

Choose the correct description of batch operations in blockchain systems.

A Batch operations execute multiple transactions atomically in one block to save gas and ensure all succeed or fail together.

B Batch operations split a single transaction into multiple smaller transactions to increase fees.

C Batch operations delay transactions indefinitely until network congestion clears.

D Batch operations are only used to mine new blocks faster.

💡 Hint

Think about why batching transactions is useful for cost and consistency.

Batch operations group multiple transactions so they execute together atomically, saving gas and ensuring either all succeed or all fail.

🔧 Debug

advanced

Why does this batch transaction fail to update all balances?

Given the following Solidity batch transfer function, why does only the first transfer succeed?

Blockchain / Solidity

function batchTransfer(address[] memory recipients, uint256[] memory amounts) public {
  require(recipients.length == amounts.length, "Mismatched arrays");
  for (uint i = 0; i < recipients.length; i++) {
    transfer(recipients[i], amounts[i]);
    revert("Batch failed");
  }
}

A The loop condition is incorrect and never runs.

B The require statement prevents any transfers from happening.

C The function lacks a payable modifier, so transfers fail.

D The revert inside the loop causes the entire batch to fail after the first transfer.

💡 Hint

Consider what happens when revert is called inside a loop.

The revert statement inside the loop causes the transaction to roll back immediately after the first transfer, so no subsequent transfers occur.

📝 Syntax

advanced

Which option correctly defines a batch operation function in Solidity?

Choose the correct Solidity function syntax for a batch token transfer.

A

function batchTransfer(address[] recipients, uint256[] amounts) public {
  for (uint i = 0; i < recipients.length; i++) {
    transfer(recipients[i], amounts[i]);
  }
}

B

function batchTransfer(address recipients[], uint256 amounts[]) public {
  for (uint i = 0; i < recipients.length; i++) {
    transfer(recipients[i], amounts[i]);
  }
}

C

function batchTransfer(address[] memory recipients, uint256[] memory amounts) public {
  for (uint i = 0; i < recipients.length; i++) {
    transfer(recipients[i], amounts[i]);
  }
}

D

function batchTransfer(address[] memory recipients, uint256[] amounts) public {
  for (uint i = 0; i < recipients.length; i++) {
    transfer(recipients[i], amounts[i]);
  }
}

💡 Hint

Remember how to declare array parameters in Solidity functions.

In Solidity, dynamic arrays passed to functions must specify the data location as memory. Option C correctly declares both arrays with memory.

🚀 Application

expert

How many successful transfers occur in this batch with partial failure handling?

Consider a batch transfer function that attempts to send tokens to multiple recipients. If a transfer fails, it skips that recipient and continues. Given the code below, how many transfers succeed?

Blockchain / Solidity

uint successCount = 0;
for (uint i = 0; i < recipients.length; i++) {
  try this.transfer(recipients[i], amounts[i]) {
    successCount++;
  } catch {
    continue;
  }
}
return successCount;

A 2

B 3

C 4

D 0

💡 Hint

Assume the second transfer fails, others succeed.

The try-catch allows skipping failed transfers. If the second transfer fails and others succeed, total successful transfers are 2.