Multiple inheritance in Blockchain / Solidity - Mini Project: Build & Apply

Multiple Inheritance in Blockchain Smart Contracts

📖 Scenario: You are building a simple blockchain smart contract system where different contracts provide different features. You want to combine these features using multiple inheritance.

🎯 Goal: Create two base contracts with specific functions, then create a derived contract that inherits from both and uses their functions.

📋 What You'll Learn

Create two base contracts named Token and Ownable with specified functions

Create a derived contract named MyToken that inherits from both Token and Ownable

Implement a function in MyToken that calls functions from both base contracts

Deploy and test the MyToken contract to show multiple inheritance works

💡 Why This Matters

🌍 Real World

Smart contracts often combine features like token management and ownership control. Multiple inheritance lets developers reuse code and build modular contracts.

💼 Career

Understanding multiple inheritance in Solidity is essential for blockchain developers creating complex decentralized applications with reusable components.

1

Create base contract Token

Write a Solidity contract named Token with a public function totalSupply that returns 1000.

Blockchain / Solidity

// Your code here

Hint

Define a contract named Token. Inside it, add a public pure function totalSupply that returns the number 1000.

2

Create base contract Ownable

Add a new contract named Ownable with a public function owner that returns the address 0x1234567890123456789012345678901234567890.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Token {
    function totalSupply() public pure returns (uint) {
        return 1000;
    }
}

// Add contract Ownable below
// Your code here

Hint

Create a contract named Ownable. Add a public pure function owner that returns the fixed address 0x1234567890123456789012345678901234567890.

3

Create derived contract MyToken with multiple inheritance

Create a contract named MyToken that inherits from both Token and Ownable. Add a public function info that returns both the total supply and owner address by calling the inherited functions.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Token {
    function totalSupply() public pure returns (uint) {
        return 1000;
    }
}

contract Ownable {
    function owner() public pure returns (address) {
        return 0x1234567890123456789012345678901234567890;
    }
}

// Create contract MyToken inheriting Token and Ownable
// Add function info() returning totalSupply and owner
// Your code here

Hint

Define MyToken inheriting from Token and Ownable. Add a function info that returns a tuple with totalSupply() and owner().

4

Test the MyToken contract output

Write a simple test function or script that calls info() on MyToken and prints the total supply and owner address separated by a space.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Token {
    function totalSupply() public pure returns (uint) {
        return 1000;
    }
}

contract Ownable {
    function owner() public pure returns (address) {
        return 0x1234567890123456789012345678901234567890;
    }
}

contract MyToken is Token, Ownable {
    function info() public pure returns (uint, address) {
        return (totalSupply(), owner());
    }
}

// Add a function to test info() and print results
// Your code here

Hint

Create a public function test that calls info(), converts the results to strings, and returns them separated by a space.

Practice

1.

What is the main purpose of multiple inheritance in blockchain smart contracts?

easy

A. To restrict a contract to inherit from only one contract

B. To allow a contract to use code from more than one contract

C. To make contracts run faster on the blockchain

D. To prevent contracts from sharing any code

Solution

1. Step 1: Understand inheritance in contracts

   Inheritance allows a contract to reuse code from another contract.

2. Step 2: Identify multiple inheritance meaning

   Multiple inheritance means inheriting from more than one contract to combine features.

3. Final Answer:

   To allow a contract to use code from more than one contract -> Option B

4. Quick Check:

   Multiple inheritance = use code from multiple contracts [OK]

Hint: Multiple inheritance means using code from many contracts [OK]

Common Mistakes:

• Thinking multiple inheritance restricts to one contract
• Confusing inheritance with contract speed
• Believing inheritance prevents code sharing

2.

Which of the following is the correct syntax to inherit from two contracts A and B in Solidity?

contract C is ? {}

easy

A. A + B

B. A & B

C. A | B

D. A, B

Solution

1. Step 1: Recall Solidity inheritance syntax

   In Solidity, multiple inheritance uses commas to separate parent contracts.

2. Step 2: Check the options

   Only A, B uses commas correctly: contract C is A, B {}.

3. Final Answer:

   A, B -> Option D

4. Quick Check:

   Use commas to list parents in Solidity inheritance [OK]

Hint: Use commas to list multiple parents in Solidity [OK]

Common Mistakes:

• Using symbols like & or + instead of commas
• Forgetting to separate parent contracts
• Writing inheritance without any separator

3.

Consider the following Solidity contracts:

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

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

contract C is A, B {
    function greet() public pure override(A, B) returns (string memory) {
        return super.greet();
    }
}

What will C().greet() return?

medium

A. "Hello from A"

B. "Hello from C"

C. Compilation error due to ambiguity

D. "Hello from B"

Solution

1. Step 1: Understand method resolution order

   In Solidity, the order of inheritance matters. The first parent contract's function is called by super.

2. Step 2: Check inheritance order and super call

   Contract C inherits A then B. Calling super.greet() calls A's greet due to C3 linearization order C, A, B.

3. Final Answer:

   "Hello from A" -> Option A

4. Quick Check:

   First parent function called by super = "Hello from A" [OK]

Hint: In Solidity, super calls first inherited (leftmost) contract's method [OK]

Common Mistakes:

• Assuming super calls last parent
• Expecting compilation error without override
• Thinking super calls child's own method

4.

Given the contracts below, what is the error in contract C?

contract A {
    function foo() public pure returns (string memory) {
        return "A";
    }
}

contract B {
    function foo() public pure returns (string memory) {
        return "B";
    }
}

contract C is A, B {
    // Missing override keyword
    function foo() public pure returns (string memory) {
        return super.foo();
    }
}

medium

A. Missing override keyword causes compilation error

B. super.foo() calls an undefined function

C. No error, code compiles and runs fine

D. Function foo() must be private

Solution

1. Step 1: Check function overriding rules

   When overriding functions from multiple parents, Solidity requires the override keyword.

2. Step 2: Identify missing override keyword

   Contract C's foo lacks override(A, B), causing a compilation error.

3. Final Answer:

   Missing override keyword causes compilation error -> Option A

4. Quick Check:

   Override keyword required when overriding multiple parents [OK]

Hint: Always add override keyword when overriding multiple parents [OK]

Common Mistakes:

• Forgetting override keyword in child function
• Assuming super.foo() is undefined
• Thinking function visibility must be private

5.

You have two contracts:

contract Token {
    function transfer() public pure virtual returns (string memory) {
        return "Token transfer";
    }
}

contract Mintable {
    function transfer() public pure virtual returns (string memory) {
        return "Mintable transfer";
    }
}

contract MyToken is Token, Mintable {
    function transfer() public pure override(Token, Mintable) returns (string memory) {
        return string.concat(Token.transfer(), " & ", Mintable.transfer());
    }
}

What will MyToken().transfer() return?

hard

A. "Mintable transfer & Token transfer"

B. Compilation error due to ambiguous override

C. "Token transfer & Mintable transfer"

D. "Token transfer"

Solution

1. Step 1: Understand explicit calls to parent functions

   MyToken's transfer calls both Token.transfer() and Mintable.transfer() explicitly.

2. Step 2: Check string concatenation order

   The returned string concatenates Token.transfer() first, then Mintable.transfer() with " & " in between.

3. Final Answer:

   "Token transfer & Mintable transfer" -> Option C

4. Quick Check:

   Explicit calls combine both parents' transfer strings [OK]

Hint: Explicitly call each parent to combine their outputs [OK]

Common Mistakes:

• Assuming super calls only one parent
• Expecting compilation error without override
• Mixing order of concatenation