Visibility modifiers (public, private, internal, external) in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - Visibility modifiers (public, private, internal, external)

Define Function with Visibility

↓

Call Function

↓

Check Visibility Modifier

↓

public

↓

Accessible

Functions have visibility rules that control where they can be called from: public (anywhere), private (only inside the contract), internal (inside and derived contracts), external (only from outside).

Execution Sample

Blockchain / Solidity

contract Example {
  function pub() public {}
  function priv() private {}
  function inter() internal {}
  function ext() external {}
}

Defines four functions each with a different visibility modifier to control access.

Execution Table

Step	Function Called	Caller Location	Visibility Check	Allowed?	Reason
1	pub()	Inside contract	public allows all	Yes	Public functions can be called anywhere
2	priv()	Inside contract	private only inside	Yes	Private functions accessible inside contract
3	priv()	Derived contract	private only inside	No	Private not accessible in derived contracts
4	inter()	Derived contract	internal inside+derived	Yes	Internal accessible in derived contracts
5	inter()	Outside contract	internal inside+derived	No	Internal not accessible externally
6	ext()	Outside contract	external only external	Yes	External functions callable from outside
7	ext()	Inside contract	external only external	No	External functions not callable internally
8	pub()	Outside contract	public allows all	Yes	Public functions callable anywhere

💡 Execution stops after all visibility cases are checked.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	After 6	After 7	Final
Allowed?	N/A	Yes	Yes	No	Yes	No	Yes	No	Yes

Key Moments - 3 Insights

Why can't private functions be called from derived contracts?

Private functions are only accessible inside the contract where they are defined, as shown in step 3 of the execution_table where the call from a derived contract is denied.

Why are external functions not callable from inside the contract?

External functions require calls from outside the contract, so internal calls fail as in step 7 of the execution_table.

What makes internal functions different from private?

Internal functions can be called inside the contract and from derived contracts, unlike private which is only inside the contract, as seen in steps 3 and 4.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is a private function call denied?

A Step 2

B Step 3

C Step 5

D Step 7

💡 Hint

Check the 'Allowed?' column for 'No' and the 'Function Called' column for 'priv()'

According to variable_tracker, what is the Allowed? value after step 6?

A No

B N/A

C Yes

D Unknown

💡 Hint

Look at the 'After 6' column in variable_tracker row 'Allowed?'

If the function ext() was called from inside the contract, what would happen according to execution_table?

A Call denied

B Call allowed

C Call allowed only if public

D Call allowed only if internal

💡 Hint

See step 7 in execution_table where ext() is called inside contract and is denied

Concept Snapshot

Visibility modifiers control who can call functions:
- public: callable anywhere
- private: only inside the contract
- internal: inside and derived contracts
- external: only from outside calls
Use them to protect your contract's functions.

Full Transcript

This visual execution shows how visibility modifiers in blockchain smart contracts control function access. Public functions can be called anywhere, private only inside the contract, internal inside and derived contracts, and external only from outside. The execution table traces calls to each function from different locations and checks if they are allowed. The variable tracker shows the allowed status after each step. Key moments clarify common confusions about private and external functions. The quiz tests understanding by referencing the execution steps and variable states.