Contract inheritance in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - Contract inheritance

Define Base Contract

↓

Define Derived Contract

↓

Derived inherits Base

↓

Deploy Derived Contract

↓

Access Base and Derived functions

Contract inheritance lets one contract use code from another, like a child getting traits from a parent.

Execution Sample

Blockchain / Solidity

contract Base {
    function greet() public pure returns (string memory) {
        return "Hello from Base";
    }
}

contract Derived is Base {
    function greetDerived() public pure returns (string memory) {
        return "Hello from Derived";
    }
}

This code shows a Derived contract inheriting from Base, so it can use Base's greet function.

Execution Table

Step	Action	Contract	Function Called	Output
1	Deploy Base contract	Base	-	-
2	Call greet()	Base	greet	"Hello from Base"
3	Deploy Derived contract	Derived	-	-
4	Call greet() via Derived	Derived	greet	"Hello from Base"
5	Call greetDerived()	Derived	greetDerived	"Hello from Derived"
6	Call greetDerived() via Base (error)	Base	greetDerived	Error: function not found

💡 Execution stops after testing inherited and own functions, showing inheritance works and limits.

Variable Tracker

Variable	Start	After Deploy Base	After Deploy Derived	Final
Base contract deployed	No	Yes	Yes	Yes
Derived contract deployed	No	No	Yes	Yes
greet() accessible in Base	No	Yes	Yes	Yes
greetDerived() accessible in Derived	No	No	Yes	Yes

Key Moments - 3 Insights

Why can Derived call greet() even though it is defined in Base?

Because Derived inherits Base, it gets access to Base's functions, as shown in execution_table row 4.

Why can't Base call greetDerived()?

Base does not inherit Derived, so it has no access to Derived's functions, shown in execution_table row 6.

What happens when we deploy Derived contract?

Derived contract includes Base's code and its own, so both sets of functions are available, as seen in variable_tracker.

Visual Quiz - 3 Questions

Look at the execution table, what output does calling greet() on Derived produce?

A "Hello from Derived"

B "Hello from Base"

C Error: function not found

D No output

💡 Hint

Check execution_table row 4 where Derived calls greet()

At which step does the Derived contract get deployed?

A Step 1

B Step 5

C Step 3

D Step 6

💡 Hint

Look at execution_table row 3 for Derived deployment

If Base inherited Derived instead, what would happen when calling greetDerived() on Base?

A It would return "Hello from Derived"

B It would return "Hello from Base"

C Error: function not found

D It would cause a deployment error

💡 Hint

Inheritance direction controls function availability, see key_moments about Base not accessing Derived functions

Concept Snapshot

Contract inheritance lets one contract (Derived) use code from another (Base).
Syntax: contract Derived is Base { ... }
Derived can call Base's functions.
Base cannot call Derived's functions.
Useful for code reuse and extending functionality.

Full Transcript

Contract inheritance in blockchain means one contract can use code from another contract. We define a Base contract with a greet function. Then we define a Derived contract that inherits Base. When we deploy Derived, it has both its own functions and Base's functions. Calling greet() on Derived returns Base's greeting. Calling greetDerived() on Base causes an error because Base does not inherit Derived. This shows inheritance direction matters. Derived inherits Base, so it can use Base's code, but not the other way around.

Practice

1. What keyword is used in Solidity to inherit from a parent contract?

easy

A. extends

B. inherits

C. is

D. implements

Solution

1. Step 1: Understand Solidity inheritance syntax

   In Solidity, the keyword is is used to inherit from a parent contract.

2. Step 2: Compare with other options

   Keywords like extends, inherits, and implements are not used in Solidity for inheritance.

3. Final Answer:

   is -> Option C

4. Quick Check:

   Inheritance keyword = is [OK]

Hint: Remember: Solidity uses 'is' for inheritance [OK]

Common Mistakes:

• Confusing Solidity with other languages like Java using 'extends'
• Using 'implements' which is for interfaces
• Trying 'inherits' which is not a Solidity keyword

2. Which of the following is the correct way to declare a function in a parent contract that can be overridden in Solidity?

easy

A. function foo() public virtual {}

B. function foo() public abstract {}

C. function foo() public override {}

D. function foo() public final {}

Solution

1. Step 1: Identify the keyword to allow overriding

   In Solidity, to allow a function to be overridden in child contracts, it must be marked virtual.

2. Step 2: Check other options for correctness

   override is used in child contracts, abstract is for abstract contracts, and final is not a Solidity keyword.

3. Final Answer:

   function foo() public virtual {} -> Option A

4. Quick Check:

   Allow override = virtual [OK]

Hint: Use 'virtual' in parent to allow overrides [OK]

Common Mistakes:

• Using 'override' in parent instead of child
• Confusing 'abstract' with 'virtual'
• Using non-existent 'final' keyword

3. What will be the output of the following Solidity code when calling greet() on contract Child?

contract Parent {
    function greet() public virtual returns (string memory) {
        return "Hello from Parent";
    }
}

contract Child is Parent {
    function greet() public override returns (string memory) {
        return "Hello from Child";
    }
}

medium

A. Runtime error

B. "Hello from Parent"

C. Compilation error due to missing override

D. "Hello from Child"

Solution

1. Step 1: Understand function overriding

   The Child contract overrides the greet() function from Parent using override keyword.

2. Step 2: Determine which function runs on Child

   Calling greet() on Child runs the overridden function returning "Hello from Child".

3. Final Answer:

   "Hello from Child" -> Option D

4. Quick Check:

   Override function output = "Hello from Child" [OK]

Hint: Child's override function runs, not parent's [OK]

Common Mistakes:

• Thinking parent function runs instead of child
• Missing 'override' keyword causing compile error
• Expecting runtime error without cause

4. Identify the error in the following Solidity code snippet:

contract Base {
    function foo() public virtual returns (string memory) {
        return "Base";
    }
}

contract Derived is Base {
    function foo() public returns (string memory) {
        return "Derived";
    }
}

medium

A. Missing 'override' keyword in Derived's foo function

B. Missing 'virtual' keyword in Base's foo function

C. Derived contract should not inherit Base

D. Function foo should be private

Solution

1. Step 1: Check overriding rules in Solidity

   When overriding a function marked virtual in the parent, the child function must use override keyword.

2. Step 2: Identify missing keyword

   The foo() function in Derived lacks the override keyword, causing a compilation error.

3. Final Answer:

   Missing 'override' keyword in Derived's foo function -> Option A

4. Quick Check:

   Override missing = compile error [OK]

Hint: Override functions must use 'override' keyword [OK]

Common Mistakes:

• Forgetting 'override' keyword in child function
• Thinking 'virtual' is needed in child function
• Assuming inheritance itself causes error

5. Given the following contracts, what will be the output of calling getMessage() on contract GrandChild?

contract Parent {
    function getMessage() public virtual returns (string memory) {
        return "Parent";
    }
}

contract Child is Parent {
    function getMessage() public virtual override returns (string memory) {
        return "Child";
    }
}

contract GrandChild is Child {
    function getMessage() public override returns (string memory) {
        return super.getMessage();
    }
}

hard

A. "Parent"

B. "Child"

C. "GrandChild"

D. Compilation error due to missing virtual

Solution

1. Step 1: Understand super keyword in Solidity inheritance

   The GrandChild contract calls super.getMessage(), which refers to the immediate parent Child implementation.

2. Step 2: Identify which function runs

   The Child contract's getMessage() returns "Child", so GrandChild returns "Child" as well.

3. Final Answer:

   "Child" -> Option B

4. Quick Check:

   super calls immediate parent = "Child" [OK]

Hint: super calls immediate parent function [OK]

Common Mistakes:

• Thinking super calls grandparent function
• Expecting 'GrandChild' string without override
• Missing 'virtual' in intermediate contract causing error