Receive and fallback functions in Blockchain / Solidity - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a receive function that accepts Ether.

Blockchain / Solidity

receive() external [1] {}

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

Avirtual

Bexternal

Cpayable

Dview

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to add 'payable' causes the function to reject Ether.

Using 'view' or 'virtual' instead of 'payable' is incorrect.

The receive function must be marked payable to accept Ether.

2fill in blank

medium

Complete the code to declare a fallback function that can receive Ether.

Blockchain / Solidity

fallback() external [1] {}

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

Apayable

Bview

Cpure

Dvirtual

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting 'payable' causes the fallback function to reject Ether.

Using 'view' or 'pure' is invalid for fallback functions that receive Ether.

The fallback function must be marked payable to accept Ether sent without data.

3fill in blank

hard

Fix the error in the fallback function declaration to accept Ether.

Blockchain / Solidity

fallback() external [1] {}

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

Apayable

Bview

Cpure

Dnonpayable

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'view' or 'pure' prevents Ether reception.

Forgetting 'payable' causes runtime errors when sending Ether.

Only payable fallback functions can accept Ether.

4fill in blank

hard

Fill both blanks to create a receive function that logs an event when Ether is received.

Blockchain / Solidity

event Received(address sender, uint amount);

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

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

Apayable

Bvalue

Cgas

Dview

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'view' instead of 'payable' prevents receiving Ether.

Using 'msg.gas' instead of 'msg.value' gives wrong data.

The receive function must be payable to accept Ether, and msg.value gives the amount of Ether sent.

5fill in blank

hard

Fill all three blanks to create a fallback function that forwards received Ether to a payable address.

Blockchain / Solidity

fallback() external [1] {
    address payable recipient = payable(msg.sender);
    (bool success, ) = recipient.call{value: msg.[2]([3]);
    require(success, "Transfer failed.");
}

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

Apayable

Bvalue

C""

Dgas

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting 'payable' causes the fallback to reject Ether.

Using 'msg.gas' instead of 'msg.value' sends wrong amount.

Omitting the empty string for calldata causes syntax errors.

The fallback function must be payable to receive Ether. msg.value is the amount sent, and "" represents empty call data.

Practice

1.

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

easy

A. To reject all incoming Ether transfers

B. To handle calls to unknown functions with data

C. To execute code when a contract is created

D. To handle plain Ether transfers without any data

Solution

1. Step 1: Understand the role of receive()

   The receive() function is designed to accept Ether sent to the contract without any accompanying data.

2. Step 2: Differentiate from fallback function

   The fallback function handles calls with data or unknown function calls, while receive() is only for plain Ether transfers.

3. Final Answer:

   To handle plain Ether transfers without any data -> Option D

4. Quick Check:

   receive() handles plain Ether = C [OK]

Hint: receive() handles Ether with no data, fallback handles calls with data [OK]

Common Mistakes:

• Confusing receive() with fallback()
• Thinking receive() handles calls with data
• Assuming receive() rejects Ether

2.

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

?

easy

A. receive() external payable {}

B. function receive() public {}

C. fallback() external payable {}

D. function receive() external {}

Solution

1. Step 1: Recall receive() function syntax

   The receive() function must be declared without the function keyword, must be external and payable.

2. Step 2: Check each option

   receive() external payable {} matches the correct syntax. Options using the function keyword are invalid, as are those lacking payable or using fallback instead of receive.

3. Final Answer:

   receive() external payable {} -> Option A

4. Quick Check:

   receive() syntax requires external payable = B [OK]

Hint: receive() has no function keyword, must be external payable [OK]

Common Mistakes:

• Adding 'function' keyword to receive()
• Omitting 'payable' modifier
• Confusing fallback() with receive()

3.

Consider this Solidity contract snippet:

contract Test {
    event Log(string func);

    receive() external payable {
        emit Log("receive");
    }

    fallback() external payable {
        emit Log("fallback");
    }
}

What event is emitted when someone sends 1 Ether with empty data?

medium

A. "receive"

B. "fallback"

C. No event emitted

D. Compilation error

Solution

1. Step 1: Identify the call type

   Sending Ether with empty data triggers the receive() function if it exists.

2. Step 2: Check which event is emitted

   The receive() function emits the event with "receive" string.

3. Final Answer:

   "receive" -> Option A

4. Quick Check:

   Empty data + Ether triggers receive() = "receive" [OK]

Hint: Empty data + Ether calls receive(), else fallback [OK]

Common Mistakes:

• Assuming fallback() triggers on empty data
• Thinking no event is emitted
• Confusing receive() and fallback() roles

4.

Given this contract snippet, what is the error?

contract Example {
    fallback() external {
        // code
    }

    receive() external {
        // code
    }
}

medium

A. receive() cannot be declared after fallback()

B. Both fallback and receive must be payable to accept Ether

C. fallback() must have the function keyword

D. No error, code is correct

Solution

1. Step 1: Check payable modifiers

   To accept Ether, both receive() and fallback() must be marked payable.

2. Step 2: Analyze given code

   Both functions lack payable, so contract cannot receive Ether via these functions.

3. Final Answer:

   Both fallback and receive must be payable to accept Ether -> Option B

4. Quick Check:

   Missing payable means no Ether acceptance = A [OK]

Hint: Missing payable means no Ether accepted by receive or fallback [OK]

Common Mistakes:

• Thinking order of functions matters
• Assuming fallback needs 'function' keyword
• Ignoring payable requirement

5.

You want your contract to accept Ether sent with or without data, and log which function was called. Which is the best way to implement this?

?

hard

A. Do not implement receive or fallback; use a regular payable function instead

B. Implement only receive() external payable function and ignore fallback

C. Implement both receive() external payable and fallback() external payable functions, each emitting a distinct event

D. Implement only fallback() external payable function to handle all cases

Solution

1. Step 1: Understand Ether transfer scenarios

   Ether can be sent with empty data (calls receive) or with data (calls fallback).

2. Step 2: Implement both functions to handle all cases

   Implementing both receive() and fallback() as external payable lets the contract accept Ether in both cases and emit distinct events.

3. Final Answer:

   Implement both receive() external payable and fallback() external payable functions, each emitting a distinct event -> Option C

4. Quick Check:

   Both functions needed for all Ether types = D [OK]

Hint: Use both receive() and fallback() payable to cover all Ether sends [OK]

Common Mistakes:

• Implementing only one function and missing some Ether transfers
• Ignoring fallback for calls with data
• Using regular payable function instead of receive/fallback