Payable functions in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Solidity payable function call?

Consider the following Solidity contract snippet. What will be the value of contractBalance after calling deposit with 1 ether?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Wallet {
    uint public contractBalance;

    function deposit() public payable {
        contractBalance += msg.value;
    }
}

A contractBalance will be 0 because msg.value is not added

B contractBalance will be 1000000000000000000 (1 ether in wei)

C contractBalance will be 1 because ether is counted as 1

D The code will not compile due to missing payable keyword

💡 Hint

Remember that msg.value holds the amount of wei sent with the transaction.

The deposit function is marked payable, so it can receive ether. The msg.value contains the amount sent in wei. Adding it to contractBalance updates the balance correctly.

❓ Predict Output

intermediate

What error occurs when calling a non-payable function with ether?

Given this Solidity contract, what happens if you call withdraw and send 1 ether along with the call?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Bank {
    function withdraw() public {
        // withdraw logic
    }
}

A Transaction reverts with error: 'non-payable function cannot accept ether'

B Transaction succeeds and ether is accepted

C Transaction reverts with 'out of gas' error

D Transaction succeeds but ether is ignored

💡 Hint

Check if the function is marked payable or not.

Functions not marked payable reject any ether sent with the call. The transaction reverts with an error indicating the function cannot accept ether.

🔧 Debug

advanced

Why does this payable fallback function not receive ether?

Examine the contract below. Why does sending ether to this contract fail to increase its balance?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Test {
    fallback() external {
        // fallback without payable
    }
}

A Fallback function is not marked payable, so it rejects ether

B Fallback function must be named receive to accept ether

C Fallback functions cannot be external

D Contract balance cannot increase without a deposit function

💡 Hint

Check the fallback function signature and payable keyword.

Fallback functions must be marked payable to accept ether. Without payable, any ether sent causes the transaction to revert.

🧠 Conceptual

advanced

Which statement about payable functions is true?

Select the correct statement about payable functions in Solidity.

A All functions can receive ether regardless of payable keyword

B Payable keyword is optional if the contract has a receive function

C Payable functions automatically reject ether sent

D Only functions marked payable can receive ether during a call

💡 Hint

Think about how Solidity controls ether transfers to functions.

In Solidity, only functions marked payable can receive ether. Other functions reject ether and cause the transaction to revert.

❓ Predict Output

expert

What is the contract balance after these calls?

Given the contract below, what is the value of address(this).balance after these calls? 1. Call deposit with 2 ether 2. Call withdraw with 1 ether Assume withdraw sends ether back to the caller.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Vault {
    function deposit() public payable {
        // Accept ether
    }

    function withdraw(uint amount) public {
        payable(msg.sender).transfer(amount);
    }
}

A 0 ether

B 2 ether (2000000000000000000 wei)

C 1 ether (1000000000000000000 wei)

D 3 ether

💡 Hint

Consider how much ether is sent and withdrawn from the contract balance.

The contract receives 2 ether in deposit. Then it sends 1 ether back in withdraw. So the contract balance is 1 ether.