Ethereum: Does delegate calling to a non-payable function result into a revert?

Ethereum: Does Delegate Calling to a Non-Payable Function Result in a Revert?

Delegate calling to non-payable functions can be a complex topic in Ethereum, and understanding the implications is crucial for building secure and reliable smart contracts. In this article, we will delve into the issue of delegate calls to non-payable functions and explore whether they may result in a revert.

What is a Revert?

In Ethereum, a revert occurs when the execution of a function or operation returns an error message that indicates a failure or unexpected condition has occurred. This can happen due to various reasons such as invalid inputs, out-of-range values, or incorrect logic.

Delegate Calling Non-Payable Functions

When you delegate a call to a non-payable function in your smart contract, it’s essential to understand the implications of doing so. A non-payable function is one that cannot be called from outside the contract and must always return automatically, without any chance of being paid or compensated.

The Issue with Non-Payable Functions

When you delegate a call to a non-payable function, the following issues arise:

• No Return Value: The non-payable function does not return any value, which means that there is no way to recover from an error.

• Unrecoverable Errors: Even if an error occurs in the non-payable function, it will be unrecoverable due to the lack of a return value.

• No Error Handling: The contract cannot detect or handle errors within the non-payable function, which can lead to unexpected behavior or crashes.

Does Delegate Calling to a Non-Payable Function Result in a Revert?

Yes, delegate calling to a non-payable function can result in a revert. When an error occurs within the non-payable function, it will be propagated up the call chain until it reaches the contract’s call' function or another contract that can recover from the error.

For example, consider a scenario where you have a payable functionbatch(bytes[] calldata calls)and you want to delegate call to a non-payable functionnonPayableFunction. ThenonPayableFunctionperforms an operation that results in an error:

pragma solidity ^0.8.0;


contract NonPayableFunction {

    function myFunction() public payable returns (bool) {

        // Simulate an error: 2^32 - 1 > 1 is not true

        bool success = false;

        

        if (success) {

            return success;

        } else {

            revert();

        }

    }

}

In this example, the batchfunction will delegate a call to thenonPayableFunction. If an error occurs innonPayableFunction, the contract will revert and throw a reversion error.

• Implement Error Handling: Design your contract to handle errors and recover from them usingrevert’ statements or other error-handling mechanisms.

• Use check and require Statements: These can be used to validate inputs before executing a function, preventing errors caused by invalid inputs.

In conclusion, delegate calling non-payable functions in Ethereum can result in a revert due to the lack of return value or recoverability from errors. However, by understanding the implications of this behavior and implementing error handling mechanisms, you can mitigate this risk and build more robust smart contracts.