Solidity — Part 2- Payable, Fallback, and Receive

Solidity is a programming language used to write smart contracts on the Ethereum blockchain. Smart contracts are self-executing contracts that allow for the automatic transfer of digital assets when certain conditions are met. In this series, we will cover some of the more tricky areas of Solidity, aimed at the Intermediate level of Solidity skills.

In Part 1 we covered assert, require, and revert.

Among these are the payable, fallback, and receive functions. This article aims to provide intermediate-level Solidity developers with a deeper understanding of these functions, their use cases, and their implications for gas efficiency.

Payable

In Solidity, the payable modifier is used to allow a function to receive Ether. Without this modifier, if you attempt to send Ether to a function, the transaction will be rejected and will fail.

Here’s a basic example of a payable function:

function deposit() public payable {
    // This function can receive Ether
}

In this example, the deposit function can accept Ether because it's marked as payable. If we remove the payable keyword and attempt to send Ether, the transaction will fail.

Fallback

The fallback function in Solidity is a special function that is executed when a contract receives Ether along with a call to a function that does not exist in the contract, or if no data is supplied with the transaction. This function must be marked as payable if you want the contract to be able to receive Ether in this way.

Here’s an example of a payable fallback function:

fallback() external payable {
    // This function is executed on a call to the contract if none of the other
    // functions match the given function signature, or if no data is supplied at all
}

The fallback function is a catch-all function that can be used when no other function matches the function signature in the call or when the contract receives plain Ether without any data. However, it’s important to note that fallback functions are often more expensive in terms of gas costs because their execution requires more computational steps.

Receive

Starting from Solidity 0.6.0, a new function type was introduced: the receive function. This function is triggered when a contract receives plain Ether (without data). This function must also be marked as payable.

Here’s an example of a receive function:

receive() external payable {
    // This function is executed when a contract receives plain Ether (without data)
}

The receive the function is specifically designed to handle situations where a contract is meant to directly receive Ether without any additional data or function calls. It provides a more explicit and readable way to handle such transactions and is more gas-efficient than the fallback function.

Conclusion

Understanding the payable, fallback, and receive functions in Solidity are crucial for developing effective and secure smart contracts. These functions provide the means for your contracts to interact with Ether in a controlled and safe manner.

Remember, the payable modifier allows a function to receive Ether, the fallback the function provides a catch-all mechanism for non-existent function calls or plain Ether transfers, and the receive the function offers a more gas-efficient way to handle plain Ether transfers.

In Part 3 we cover Inheritance, Virtual, Override, and Super.