Receiving Ether in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output when sending Ether to this contract?

Consider the following Solidity contract that can receive Ether. What will be the value of received after sending 1 Ether?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Receiver {
    uint public received = 0;

    receive() external payable {
        received = msg.value;
    }
}

A received will be 1 ether (1000000000000000000 wei)

B received will be 0

C received will be the sender's address

D The contract will reject the Ether and revert

💡 Hint

The receive() function is called when Ether is sent without data. msg.value holds the amount of Ether sent in wei.

The receive() function updates received with msg.value, which is the amount of Ether sent in wei. Sending 1 Ether means msg.value is 1000000000000000000 wei.

❓ Predict Output

intermediate

What happens if a contract has no receive or fallback function and receives Ether?

Given this contract, what happens when it receives Ether?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract NoReceive {
    uint public balance = 0;
}

A The contract accepts Ether but balance stays zero

B The contract accepts Ether and balance updates automatically

C The contract rejects the Ether and the transaction reverts

D The contract throws a warning but accepts Ether

💡 Hint

Contracts without receive() or payable fallback() cannot accept plain Ether transfers.

Without a receive() or payable fallback(), the contract cannot accept Ether sent without data, so the transaction reverts.

🔧 Debug

advanced

Why does this contract fail to receive Ether?

Examine the contract below. It is supposed to receive Ether and update receivedAmount. Why does sending Ether fail?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract ReceiverFail {
    uint public receivedAmount;

    fallback() external {
        receivedAmount = msg.value;
    }
}

A The contract does not have a constructor to initialize receivedAmount

B The fallback function is not marked payable, so it rejects Ether

C msg.value is always zero in fallback functions

D The fallback function should be named receive to accept Ether

💡 Hint

To accept Ether, fallback or receive functions must be marked payable.

The fallback function is missing the payable keyword, so it cannot accept Ether and the transaction reverts.

📝 Syntax

advanced

Identify the syntax error in this receive function

What is wrong with this receive function code?

Blockchain / Solidity

receive() external {
    // receive Ether
}

A Missing the payable keyword in the receive function declaration

B The receive function cannot be external

C The receive function must have a return type

D The receive function must have a function name

💡 Hint

Receive functions must be able to accept Ether.

Receive functions must be declared payable to accept Ether transfers. Missing payable causes a syntax error.

🚀 Application

expert

How many times can a contract receive Ether in this scenario?

Consider this contract deployed on Ethereum. A user sends 0.5 Ether twice in separate transactions. How many times is the receive() function called?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract MultiReceive {
    uint public count = 0;

    receive() external payable {
        count++;
    }
}

A It depends on the gas limit of the transactions

B 1 time, because the contract only accepts Ether once

C 0 times, receive is only called on contract creation

D 2 times, once for each Ether transfer

💡 Hint

The receive() function is triggered every time Ether is sent without data.

Each Ether transfer triggers the receive() function, so sending Ether twice calls it twice, incrementing count twice.