Receiving Ether in Blockchain / Solidity - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to make the contract able to receive Ether.

Blockchain / Solidity

contract ReceiveEther {
    receive() external payable [1] {
        // Function to receive Ether
    }
}

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

Apublic payable {}

B{}

Cexternal {}

Dpayable {}

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting the payable keyword

Using public instead of external

Leaving the function body empty without braces

The receive function must be marked payable to accept Ether.

2fill in blank

medium

Complete the fallback function to receive Ether when no other function matches.

Blockchain / Solidity

contract ReceiveEther {
    fallback() external [1] {
        // fallback function
    }
}

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

Aview

Bpublic

Cpayable

Dpure

Attempts:

3 left

💡 Hint

Common Mistakes

Not marking fallback as payable

Using view or pure which disallow state changes

The fallback function must be marked payable to accept Ether.

3fill in blank

hard

Fix the error in the receive function to correctly accept Ether.

Blockchain / Solidity

contract ReceiveEther {
    receive() external [1] {
        // receive Ether
    }
}

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

Apayable

Bpayable view

Cpure

Dview

Attempts:

3 left

💡 Hint

Common Mistakes

Adding view or pure modifiers

Omitting payable keyword

The receive function must be external payable without view or pure modifiers.

4fill in blank

hard

Fill both blanks to create a receive function that accepts Ether and emits an event.

Blockchain / Solidity

contract ReceiveEther {
    event Received(address sender, uint amount);

    receive() external [1] {
        emit Received(msg.sender, msg.value[2]);
    }
}

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

Apayable

Bpublic

C+

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using public instead of payable

Using multiplication instead of addition in event emit

The receive function must be payable and the event emits msg.value as is, so the plus sign is correct to complete the expression.

5fill in blank

hard

Fill both blanks to create a fallback function that accepts Ether, updates balance, and emits an event.

Blockchain / Solidity

contract ReceiveEther {
    mapping(address => uint) public balances;
    event Received(address sender, uint amount);

    fallback() external [1] {
        balances[msg.sender] [2] msg.value;
        emit Received(msg.sender, balances[msg.sender]);
    }
}

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

Apayable

B+=

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Not marking fallback payable

Using = instead of += for balance update

Adding operators after balances[msg.sender] in event

The fallback function must be payable. Use += to add the received Ether to the sender's balance. The event emits the updated balance, so no extra operator is needed.

Practice

1.

What is the main purpose of the receive function in a Solidity contract?

easy

A. To reject incoming Ether transfers

B. To send Ether from the contract to an external address

C. To initialize contract state variables

D. To accept Ether sent to the contract without any data

Solution

1. Step 1: Understand the role of the receive function

   The receive function is a special function in Solidity that is triggered when the contract receives Ether without any calldata.

2. Step 2: Identify its purpose

   Its purpose is to accept Ether sent directly to the contract without any function call data.

3. Final Answer:

   To accept Ether sent to the contract without any data -> Option D

4. Quick Check:

   receive function = accept Ether without data [OK]

Hint: Remember: receive handles plain Ether transfers only [OK]

Common Mistakes:

• Confusing receive with fallback function
• Thinking receive sends Ether out
• Assuming receive initializes variables

2.

Which of the following is the correct syntax for a receive function in Solidity?

?

easy

A. receive() internal payable {}

B. receive() external payable {}

C. receive() external {}

D. receive() public payable {}

Solution

1. Step 1: Recall receive function requirements

   The receive function must be declared as external and payable to accept Ether without data.

2. Step 2: Match syntax

   receive() external payable {} matches the required syntax: receive() external payable {}.

3. Final Answer:

   receive() external payable {} -> Option B

4. Quick Check:

   receive must be external and payable [OK]

Hint: receive must be external and payable, no public or internal [OK]

Common Mistakes:

• Using public instead of external
• Omitting payable keyword
• Making receive internal or private

3.

Consider this Solidity contract snippet:

contract Test {
    event Received(address sender, uint amount);
    receive() external payable {
        emit Received(msg.sender, msg.value);
    }
}

What happens when someone sends 1 Ether to this contract without calling any function?

medium

A. The contract rejects the Ether and transaction fails

B. The contract accepts Ether but does not emit any event

C. The contract accepts the Ether and emits the Received event

D. The contract calls fallback function instead

Solution

1. Step 1: Analyze the receive function

   The receive function is payable and emits an event with sender and amount when Ether is received without data.

2. Step 2: Understand the behavior on Ether transfer

   Sending 1 Ether without data triggers receive, so Ether is accepted and event emitted.

3. Final Answer:

   The contract accepts the Ether and emits the Received event -> Option C

4. Quick Check:

   receive payable + emit event = accept and notify [OK]

Hint: Sending Ether without data triggers receive, not fallback [OK]

Common Mistakes:

• Thinking fallback is called instead
• Assuming no event is emitted
• Believing Ether is rejected

4.

Identify the error in this Solidity contract snippet that prevents it from receiving Ether:

contract Example {
    receive() public payable {
        // code
    }
}

medium

A. receive function must be external, not public

B. receive function must not be payable

C. receive function must have a return type

D. receive function must be internal

Solution

1. Step 1: Check receive function visibility

   The receive function must be declared as external, not public.

2. Step 2: Confirm payable requirement

   It is correctly marked payable, so no error there.

3. Final Answer:

   receive function must be external, not public -> Option A

4. Quick Check:

   receive must be external, not public [OK]

Hint: receive must be external, not public or internal [OK]

Common Mistakes:

• Using public instead of external
• Removing payable keyword
• Adding return type to receive

5.

You want to create a contract that tracks the total Ether received and rejects any Ether sent with data. Which combination of functions should you implement?

hard

A. Implement receive() external payable to accept Ether and fallback() external to revert on data

B. Implement only fallback() external payable to accept all Ether

C. Implement receive() external without payable and fallback() external payable

D. Implement receive() external payable and fallback() external payable both accepting Ether

Solution

1. Step 1: Accept Ether without data using receive

   The receive function accepts Ether sent without data and can update total received.

2. Step 2: Reject Ether sent with data using fallback

   The fallback function should revert to reject any Ether sent with data.

3. Final Answer:

   Implement receive() external payable to accept Ether and fallback() external to revert on data -> Option A

4. Quick Check:

   receive accepts plain Ether, fallback rejects data [OK]

Hint: Use receive for plain Ether, fallback to reject data [OK]

Common Mistakes:

• Making fallback payable and accepting Ether with data
• Omitting fallback to reject data
• Not marking receive payable