Receive and fallback functions in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What happens when Ether is sent to this contract?

Consider the following Solidity contract. What will be the output when 1 Ether is sent to the contract address without calling any function explicitly?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Test {
    event Log(string func);

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

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

A Transaction reverts with an error.

B The event 'fallback called' is emitted.

C The event 'receive called' is emitted.

D No event is emitted, but Ether is accepted.

💡 Hint

Sending Ether without data triggers the receive function if it exists.

When Ether is sent with empty calldata, the receive() function is called if it is defined and payable. Otherwise, fallback() is called if payable. Here, receive() exists and is payable, so it emits 'receive called'.

❓ Predict Output

intermediate

Which function is called when sending data to this contract?

Given the contract below, what event is emitted when a transaction with non-empty calldata but no matching function signature is sent?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Test {
    event Log(string func);

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

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

A The event 'fallback called' is emitted.

B Transaction reverts with an error.

C No event is emitted, Ether is refunded.

D The event 'receive called' is emitted.

💡 Hint

Fallback is called when calldata is not empty and no matching function exists.

When calldata is non-empty and no matching function exists, the fallback() function is called if payable. Here, fallback() emits 'fallback called'.

🔧 Debug

advanced

Why does this contract reject Ether transfers?

Examine the contract below. Why does sending Ether to this contract cause the transaction to revert?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Test {
    fallback() external {
        // no payable modifier
    }
}

A Because fallback() is missing the receive() function, it reverts.

B Because fallback() is not payable, it rejects Ether transfers.

C Because fallback() has no code, it reverts automatically.

D Because the contract has no constructor, it rejects Ether.

💡 Hint

Only payable functions can receive Ether.

The fallback() function is not marked payable, so any Ether sent to the contract triggers a revert because no payable receive() or fallback() exists.

📝 Syntax

advanced

Identify the syntax error in this fallback function

Which option correctly fixes the syntax error in the fallback function below?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Test {
    fallback() external payable {
        // missing function body
    }
}

A Add empty braces: fallback() external payable {}

B Add a semicolon after fallback() external payable;

C Remove payable modifier: fallback() external {}

D Add returns keyword: fallback() external payable returns (bool) {}

💡 Hint

Functions must have a body or be declared abstract.

The fallback function must have a function body enclosed in braces. Adding empty braces fixes the syntax error.

🚀 Application

expert

How many times is fallback called in this scenario?

Given the contract below, if a user sends 0 Ether with non-empty calldata that does not match any function, how many times will the fallback function be called during the transaction?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Test {
    uint public count = 0;

    fallback() external payable {
        count++;
    }

    function getCount() public view returns (uint) {
        return count;
    }
}

A Fallback is called twice, count becomes 2.

B Fallback is called once, but count remains 0 due to no Ether.

C Fallback is not called, count remains 0.

D Fallback is called once, count becomes 1.

💡 Hint

Fallback is called once per transaction if calldata does not match any function.

The fallback function is called once per transaction when calldata does not match any function. The count increments by 1 regardless of Ether sent.

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