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.

Practice

1. Which visibility modifier allows a function to be called both inside and outside the contract, including by other contracts and users?

easy

A. public

B. private

C. internal

D. external

Solution

1. Step 1: Understand visibility modifiers

   Public functions can be accessed anywhere, inside or outside the contract.

2. Step 2: Compare with other modifiers

   Private is only inside the contract, internal is inside and inherited contracts, external only callable from outside.

3. Final Answer:

   public -> Option A

4. Quick Check:

   public = open access [OK]

Hint: Public means open to all inside and outside calls [OK]

Common Mistakes:

• Confusing private with public access
• Thinking internal allows outside calls
• Assuming external works inside contract

2. Which of the following is the correct way to declare a function that can only be called from outside the contract in Solidity?

easy

A. function foo() private {}

B. function foo() external {}

C. function foo() internal {}

D. function foo() public {}

Solution

1. Step 1: Identify external function syntax

   External functions are declared with the keyword external after the function name.

2. Step 2: Check other options

   Private and internal restrict access inside the contract or inheritance, public allows all calls.

3. Final Answer:

   function foo() external {} -> Option B

4. Quick Check:

   external = outside calls only [OK]

Hint: External functions use keyword 'external' after function name [OK]

Common Mistakes:

• Using private instead of external
• Confusing public with external
• Missing parentheses or braces

3. Consider the following Solidity contract snippet:

contract Test {
    uint private data = 10;
    function getData() public view returns (uint) {
        return data;
    }
    function setData(uint _data) external {
        data = _data;
    }
}

What will happen if another contract tries to call data directly?

medium

A. It will succeed and return 10

B. It will fail because data is external

C. It will fail because data is private

D. It will succeed because data is public by default

Solution

1. Step 1: Check variable visibility

   The variable data is declared private, so it cannot be accessed outside the contract.

2. Step 2: Understand access from other contracts

   Other contracts cannot access private variables directly, only public or external functions.

3. Final Answer:

   It will fail because data is private -> Option C

4. Quick Check:

   private = no outside access [OK]

Hint: Private variables can't be accessed outside their contract [OK]

Common Mistakes:

• Assuming private variables are public by default
• Confusing external with private
• Thinking public functions expose private variables directly

4. Given this Solidity code snippet:

contract Sample {
    uint internal count = 0;
    function increment() private {
        count += 1;
    }
    function callIncrement() public {
        increment();
    }
}

Which of the following fixes the error preventing increment() from being called?

medium

A. No fix needed, code is correct

B. Change increment() visibility to internal

C. Change increment() visibility to external

D. Change increment() visibility to public

Solution

1. Step 1: Check function call context

   The function increment() is private and called inside the same contract by callIncrement().

2. Step 2: Understand private function access

   Private functions can be called inside the same contract, so this call is valid.

3. Final Answer:

   No fix needed, code is correct -> Option A

4. Quick Check:

   private functions callable inside contract [OK]

Hint: Private functions work inside same contract only [OK]

Common Mistakes:

• Thinking private functions can't be called inside contract
• Confusing internal with private
• Changing visibility unnecessarily

5. You want to create a Solidity contract where a function can only be called by this contract or contracts that inherit from it, but not by external users. Which visibility modifier should you use for this function?

hard

A. public

B. external

C. private

D. internal

Solution

1. Step 1: Understand access needs

   The function should be callable inside this contract and by derived contracts, but not externally.

2. Step 2: Match visibility modifier

   Internal visibility allows access inside the contract and by inheriting contracts only.

3. Final Answer:

   internal -> Option D

4. Quick Check:

   internal = contract + inheritance only [OK]

Hint: Internal means accessible inside and by child contracts only [OK]

Common Mistakes:

• Choosing public which allows external calls
• Choosing private which blocks inheritance access
• Confusing external with internal