Payable functions in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - Payable functions

Call function

↓

Is function payable?

No→Reject transaction

Yes↓

Accept Ether sent

↓

Execute function code

↓

Update contract balance

↓

Return success

When a function is called, the system checks if it is payable. If yes, it accepts Ether and runs the function; otherwise, it rejects the transaction.

Execution Sample

Blockchain / Solidity

contract Example {
  function deposit() public payable {
    // Accept Ether
  }
}

This contract has a payable function 'deposit' that can receive Ether when called.

Execution Table

Step	Function Called	Is Payable?	Ether Sent (wei)	Action	Contract Balance (wei)
1	deposit()	Yes	1000	Accept Ether and execute	1000
2	deposit()	Yes	500	Accept Ether and execute	1500
3	withdraw()	No	100	Reject transaction	1500

💡 At step 3, 'withdraw' is not payable, so transaction is rejected and balance stays the same.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3
contract_balance	0	1000	1500	1500

Key Moments - 2 Insights

Why does the contract reject Ether sent to a non-payable function?

Because only payable functions can accept Ether. As shown in execution_table step 3, calling 'withdraw' which is not payable causes rejection.

What happens to the contract balance when a payable function is called with Ether?

The contract balance increases by the Ether amount sent, as seen in steps 1 and 2 where balance updates from 0 to 1000 and then to 1500.

Visual Quiz - 3 Questions

Look at the execution_table, what is the contract balance after step 2?

A 1500 wei

B 1000 wei

C 500 wei

D 0 wei

💡 Hint

Check the 'Contract Balance (wei)' column at step 2 in the execution_table.

At which step is a non-payable function called and what happens?

A Step 2, transaction accepted

B Step 1, transaction accepted

C Step 3, transaction rejected

D Step 3, transaction accepted

💡 Hint

Look at 'Is Payable?' and 'Action' columns in execution_table for step 3.

If the deposit function was not marked payable, what would happen when sending Ether?

A Ether accepted and balance updated

B Transaction rejected

C Function runs but no Ether accepted

D Contract balance resets

💡 Hint

Refer to the concept_flow where non-payable functions reject Ether.

Concept Snapshot

Payable functions allow contracts to receive Ether.
Only functions marked 'payable' can accept Ether.
Sending Ether to non-payable functions rejects the transaction.
Contract balance updates when payable functions receive Ether.
Use 'payable' keyword in function declaration.

Full Transcript

Payable functions in blockchain contracts are special functions that can receive Ether when called. When a function is called, the system checks if it is marked payable. If it is, the Ether sent with the call is accepted and the function code runs. The contract's balance increases by the amount of Ether received. If the function is not payable, the transaction is rejected and no Ether is accepted. For example, a deposit function marked payable can receive Ether and increase the contract balance. Calling a non-payable function with Ether causes rejection. This behavior ensures contracts only accept Ether where intended.

Practice

1. What is the main purpose of a payable function in a blockchain smart contract?

easy

A. To allow the function to receive cryptocurrency along with the call

B. To make the function run faster

C. To restrict the function to only the contract owner

D. To prevent the function from modifying state variables

Solution

1. Step 1: Understand the role of payable

   The payable keyword marks a function that can accept cryptocurrency (like Ether) when called.

2. Step 2: Compare other options

   Options A, C, and D describe unrelated behaviors. Only To allow the function to receive cryptocurrency along with the call correctly describes the purpose of payable.

3. Final Answer:

   To allow the function to receive cryptocurrency along with the call -> Option A

4. Quick Check:

   Payable = Receive money [OK]

Hint: Payable means function can accept money sent [OK]

Common Mistakes:

• Thinking payable makes function faster
• Confusing payable with access control
• Believing payable prevents state changes

2. Which of the following is the correct syntax to declare a payable function in Solidity?

easy

A. payable function deposit() public {}

B. function deposit() payable public {}

C. function payable deposit() public {}

D. function deposit() public payable {}

Solution

1. Step 1: Recall Solidity function declaration order

   In Solidity, the visibility modifier (e.g., public) comes before payable keyword.

2. Step 2: Check each option

   function deposit() public payable {} uses correct order: function deposit() public payable {}. Options A, B, and D have incorrect keyword order or syntax.

3. Final Answer:

   function deposit() public payable {} -> Option D

4. Quick Check:

   Correct order: visibility then payable [OK]

Hint: Visibility modifier before payable keyword [OK]

Common Mistakes:

• Placing payable before function keyword
• Switching order of public and payable
• Using payable as a function name

3. What will be the output of the following Solidity function when called with 2 Ether?

contract Test {
    uint public balance;
    function deposit() public payable {
        balance = msg.value;
    }
}

medium

A. balance will be 2000000000000000000 (2 Ether in wei)

B. balance will be 2

C. Compilation error

D. balance will be 0

Solution

1. Step 1: Understand msg.value in Solidity

   msg.value holds the amount of wei (smallest Ether unit) sent with the transaction. 2 Ether equals 2 * 10^18 wei = 2000000000000000000 wei.

2. Step 2: Analyze the assignment to balance

   The function sets balance = msg.value, so balance stores the wei amount sent, which is 2000000000000000000.

3. Final Answer:

   balance will be 2000000000000000000 (2 Ether in wei) -> Option A

4. Quick Check:

   msg.value stores wei amount sent [OK]

Hint: msg.value is in wei, not Ether [OK]

Common Mistakes:

• Assuming msg.value is in Ether
• Expecting balance to be zero
• Thinking function won't compile

4. Identify the error in this Solidity function that is intended to receive Ether:

function receiveFunds() public {
    require(msg.value > 0, "Send some Ether");
}

medium

A. require condition is incorrect

B. Function must be marked payable to receive Ether

C. Function visibility should be private

D. msg.value cannot be used inside functions

Solution

1. Step 1: Check function declaration for payable

   To receive Ether, a function must be declared with the payable keyword. This function lacks it.

2. Step 2: Validate other options

   The require condition is valid, visibility can be public, and msg.value is accessible in payable functions.

3. Final Answer:

   Function must be marked payable to receive Ether -> Option B

4. Quick Check:

   Missing payable causes Ether rejection [OK]

Hint: Add payable to accept Ether in function [OK]

Common Mistakes:

• Forgetting payable keyword
• Misusing require condition
• Changing visibility unnecessarily

5. You want to create a smart contract function that accepts Ether and updates the sender's balance only if at least 1 Ether is sent. Which of the following implementations correctly achieves this?

hard

A. function deposit() payable public {
if (msg.value > 1) {
balances[msg.sender] = msg.value;
}
}

B. function deposit() public {
require(msg.value >= 1 ether, "Minimum 1 Ether required");
balances[msg.sender] += msg.value;
}

C. function deposit() public payable {
require(msg.value >= 1 ether, "Minimum 1 Ether required");
balances[msg.sender] += msg.value;
}

D. function deposit() public payable {
if (msg.value >= 1) {
balances[msg.sender] += msg.value;
}
}

Solution

1. Step 1: Check for payable keyword and require condition

   function deposit() public payable { require(msg.value >= 1 ether, "Minimum 1 Ether required"); balances[msg.sender] += msg.value; } correctly marks the function as payable and uses require(msg.value >= 1 ether) to enforce minimum Ether sent.

2. Step 2: Validate balance update and syntax

   function deposit() public payable { require(msg.value >= 1 ether, "Minimum 1 Ether required"); balances[msg.sender] += msg.value; } updates balances[msg.sender] by adding msg.value. Other options either miss payable, use wrong comparison, or incorrect balance update.

3. Final Answer:

   function deposit() public payable { require(msg.value >= 1 ether, "Minimum 1 Ether required"); balances[msg.sender] += msg.value; } -> Option C

4. Quick Check:

   Payable + require with 1 ether check [OK]

Hint: Use require with 1 ether and payable function [OK]

Common Mistakes:

• Omitting payable keyword
• Using incorrect Ether comparison
• Not updating balance correctly