Sending Ether (transfer, send, call) in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Solidity code when sending Ether using transfer?

Consider the following Solidity contract snippet. What happens when sendEther is called with 1 ether?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract TransferExample {
    event Sent(address to, uint amount);

    function sendEther(address payable recipient) public payable {
        recipient.transfer(msg.value);
        emit Sent(recipient, msg.value);
    }
}

A The transaction returns false if the recipient rejects the Ether.

B The transaction always succeeds regardless of recipient's fallback gas usage.

C The transaction reverts if the recipient's fallback function uses more than 2300 gas.

D The transaction sends Ether asynchronously and does not wait for confirmation.

💡 Hint

Recall that transfer forwards a fixed gas stipend of 2300 gas.

The transfer method forwards exactly 2300 gas to the recipient. If the recipient's fallback or receive function requires more gas, the transaction reverts.

❓ Predict Output

intermediate

What does the send method return in this Solidity example?

Given this contract snippet, what is the value of success after calling sendEther?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract SendExample {
    function sendEther(address payable recipient) public payable returns (bool) {
        bool success = recipient.send(msg.value);
        return success;
    }
}

A True if the Ether was sent successfully, false otherwise.

B Throws an exception on failure instead of returning false.

C Always true, send never fails.

D Returns the amount of gas used by the send operation.

💡 Hint

Remember that send returns a boolean indicating success or failure.

The send method returns true if the Ether transfer succeeded, otherwise false. It does not revert on failure.

❓ Predict Output

advanced

What is the output of this Solidity code using call to send Ether?

Analyze the following contract. What does the sendViaCall function return when called with 1 ether?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract CallExample {
    event Sent(address to, uint amount, bool success);

    function sendViaCall(address payable recipient) public payable returns (bool) {
        (bool success, ) = recipient.call{value: msg.value}("");
        emit Sent(recipient, msg.value, success);
        return success;
    }
}

A Always reverts if the recipient rejects the Ether.

B Returns true if the Ether was sent successfully, false otherwise.

C Returns the amount of gas used by the call.

D Returns false if the recipient's fallback function uses more than 2300 gas.

💡 Hint

Recall that call returns a boolean success and forwards all remaining gas by default.

The call method returns a boolean indicating success or failure. It forwards all gas by default, so it does not revert due to gas stipend limits like transfer.

🧠 Conceptual

advanced

Which statement correctly describes the difference between transfer, send, and call for sending Ether?

Choose the option that best explains the key difference between transfer, send, and call when sending Ether in Solidity.

A <code>transfer</code> and <code>send</code> forward 2300 gas, <code>call</code> forwards all remaining gas and returns success status.

B <code>transfer</code> forwards all gas, <code>send</code> reverts on failure, <code>call</code> forwards 2300 gas.

C <code>send</code> throws on failure, <code>transfer</code> returns false, <code>call</code> always succeeds.

D <code>call</code> forwards 2300 gas, <code>send</code> forwards all gas, <code>transfer</code> returns success status.

💡 Hint

Think about gas forwarding and error handling differences.

transfer and send forward a fixed 2300 gas stipend. transfer reverts on failure, send returns false. call forwards all remaining gas and returns a boolean success status.

🔧 Debug

expert

Why does this call-based Ether transfer fail unexpectedly?

Consider this contract snippet. The sendViaCall function returns false unexpectedly when sending Ether to a contract with a fallback function that uses more than 2300 gas. Why?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Receiver {
    fallback() external payable {
        // Uses more than 2300 gas
        for (uint i = 0; i < 1000; i++) {}
    }
}

contract Sender {
    function sendViaCall(address payable recipient) public payable returns (bool) {
        (bool success, ) = recipient.call{value: msg.value, gas: 2300}("");
        return success;
    }
}

A Because the call does not send any Ether due to missing value parameter.

B Because call always forwards all gas, so the fallback function runs out of gas.

C Because the fallback function is not payable, causing the call to fail.

D Because the call explicitly limits gas to 2300, which is insufficient for the fallback function.

💡 Hint

Check the gas parameter in the call and the fallback function's gas usage.

The call explicitly sets gas to 2300, which is the minimum stipend. The fallback function uses more gas, so it runs out of gas and the call returns false.