Why functions define contract behavior in Blockchain / Solidity - Visual Breakdown

Concept Flow - Why functions define contract behavior

User calls function

↓

Function receives input

↓

Function executes logic

↓

Function updates contract state or returns value

↓

Contract behavior changes or outputs result

↓

User sees outcome

Functions in a contract receive inputs, run code, update state or return values, defining how the contract behaves.

Execution Sample

Blockchain / Solidity

mapping(address => uint) balance;

function deposit(uint amount) public {
    balance[msg.sender] += amount;
}

function getBalance() public view returns (uint) {
    return balance[msg.sender];
}

A deposit function adds to the user's balance; getBalance returns the current balance.

Execution Table

Step	Action	Input	State Change	Output
1	User calls deposit	amount=10	balance[user] = 0 + 10 = 10	none
2	User calls getBalance	none	state unchanged	returns 10
3	User calls deposit	amount=5	balance[user] = 10 + 5 = 15	none
4	User calls getBalance	none	state unchanged	returns 15

💡 Execution stops after returning balance or updating state as per function logic.

Variable Tracker

Variable	Start	After Step 1	After Step 3	Final
balance[user]	0	10	15	15

Key Moments - 2 Insights

Why does calling deposit change the contract state but getBalance does not?

Because deposit updates the balance variable (see steps 1 and 3 in execution_table), while getBalance only reads and returns the balance without changing it (steps 2 and 4).

What happens if a function is called with no input?

Functions like getBalance that don't need input can be called without parameters and still return data, as shown in steps 2 and 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is balance[user] after step 3?

A 10

B 5

C 15

D 0

💡 Hint

Check the 'State Change' column at step 3 in the execution_table.

At which step does the contract state NOT change?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look for 'state unchanged' in the 'State Change' column in execution_table.

If deposit is called with amount=20 at step 3 instead, what would balance[user] be after?

A 30

B 20

C 15

D 10

💡 Hint

Add the new amount to the previous balance from variable_tracker.

Concept Snapshot

Functions in blockchain contracts define behavior by:
- Receiving inputs (parameters)
- Executing code to update contract state or return data
- Changing contract state only when modifying variables
- Returning values without state change for view functions
- Acting as the interface users interact with

Full Transcript

In blockchain contracts, functions are the building blocks that define how the contract behaves. When a user calls a function, it receives inputs and runs code. Some functions update the contract's state variables, changing stored data. Others just read data and return it without changing anything. For example, a deposit function adds to a user's balance, changing the state, while a getBalance function returns the current balance without changing state. This step-by-step execution shows how functions control contract behavior by managing inputs, state changes, and outputs.

Practice

1.

Why do functions define contract behavior in blockchain programming?

easy

A. They specify what actions the contract can perform

B. They store data permanently on the blockchain

C. They create new blockchain networks

D. They control the blockchain consensus mechanism

Solution

1. Step 1: Understand contract behavior

   Contract behavior means what the contract can do or how it responds to calls.

2. Step 2: Role of functions in contracts

   Functions define specific actions users can trigger, shaping contract behavior.

3. Final Answer:

   They specify what actions the contract can perform -> Option A

4. Quick Check:

   Functions = Define contract actions [OK]

Hint: Functions show what contract can do [OK]

Common Mistakes:

• Confusing functions with data storage
• Thinking functions create blockchains
• Mixing contract behavior with consensus

2.

Which of the following is the correct syntax to define a function named transfer in a Solidity contract?

easy

A. function transfer[] {}

B. def transfer() {}

C. func transfer() {}

D. function transfer() public {}

Solution

1. Step 1: Identify Solidity function syntax

   Solidity uses the keyword function followed by the name and parentheses.

2. Step 2: Check each option

   function transfer() public {} matches Solidity syntax; others use Python or invalid forms.

3. Final Answer:

   function transfer() public {} -> Option D

4. Quick Check:

   Solidity functions start with 'function' [OK]

Hint: Solidity functions start with 'function' keyword [OK]

Common Mistakes:

• Using Python or other language syntax
• Missing parentheses after function name
• Using brackets [] instead of parentheses ()

3.

Consider this Solidity function inside a contract:

function getBalance() public view returns (uint) {
    return address(this).balance;
}

What does calling getBalance() return?

medium

A. The total supply of tokens

B. The balance of the caller's address

C. The balance of the contract's address in wei

D. The number of transactions made

Solution

1. Step 1: Analyze the function code

   The function returns address(this).balance, which is the contract's own balance.

2. Step 2: Understand what address(this).balance means

   It gives the amount of ether held by the contract in wei (smallest ether unit).

3. Final Answer:

   The balance of the contract's address in wei -> Option C

4. Quick Check:

   address(this).balance = contract's ether balance [OK]

Hint: address(this).balance returns contract's ether balance [OK]

Common Mistakes:

• Thinking it returns caller's balance
• Confusing balance with token supply
• Assuming it counts transactions

4.

Identify the error in this Solidity function that should transfer ether:

function sendEther(address recipient, uint amount) public {
    recipient.transfer(amount);
}

medium

A. Cannot call transfer on address type directly

B. Missing payable keyword on function

C. Amount should be in wei, not uint

D. Function must be private

Solution

1. Step 1: Examine the transfer call

   recipient.transfer(amount) where recipient is typed as address.

2. Step 2: Solidity ether transfer rules

   transfer is a method only on address payable. Must use payable(recipient).transfer(amount).

3. Final Answer:

   Cannot call transfer on address type directly -> Option A

4. Quick Check:

   transfer requires address payable [OK]

Hint: Solidity transfer requires payable address [OK]

Common Mistakes:

• Assuming transfer works without payable
• Confusing address types for transfer
• Thinking function visibility causes error

5.

You want to create a function in a smart contract that only allows the owner to change a stored value. Which function behavior best defines this contract logic?

hard

A. A private function that anyone can call

B. A public function with a check that only the owner can update the value

C. A public function that updates the value without restrictions

D. A function that automatically updates value every block

Solution

1. Step 1: Understand access control in contract functions

   To restrict actions, functions must check caller identity (e.g., owner).

2. Step 2: Identify function behavior that enforces owner-only update

   A public function with an owner check allows controlled access while being callable.

3. Final Answer:

   A public function with a check that only the owner can update the value -> Option B

4. Quick Check:

   Owner check in function controls access [OK]

Hint: Use owner check inside public function [OK]

Common Mistakes:

• Making function private but callable by anyone
• Not restricting access in public functions
• Assuming automatic updates enforce ownership