Multiple inheritance in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of multiple inheritance method call

What is the output of this Solidity contract when calling getValue() on Child?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract ParentA {
    function getValue() public pure virtual returns (string memory) {
        return "A";
    }
}

contract ParentB {
    function getValue() public pure virtual returns (string memory) {
        return "B";
    }
}

contract Child is ParentA, ParentB {
    function getValue() public pure override(ParentA, ParentB) returns (string memory) {
        return super.getValue();
    }
}

A Compilation error due to ambiguous super call

B "B"

C "A"

D "AB"

💡 Hint

In Solidity, the order of inheritance matters for super calls.

In Solidity, when multiple inheritance is used, the order of base contracts in the inheritance list determines which parent contract's method is called by super. Here, ParentA is listed first, so super.getValue() calls ParentA's version, returning "A".

❓ Predict Output

intermediate

Diamond problem resolution in Solidity

Given these contracts, what will Child.getValue() return?

Blockchain / Solidity

pragma solidity ^0.8.0;

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

contract B is A {
    function getValue() public pure virtual override returns (string memory) {
        return string(abi.encodePacked("B", super.getValue()));
    }
}

contract C is A {
    function getValue() public pure virtual override returns (string memory) {
        return string(abi.encodePacked("C", super.getValue()));
    }
}

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

A "BC"

B "BCA"

C Compilation error due to inheritance order

D "CBA"

💡 Hint

Remember Solidity uses C3 linearization for inheritance order.

Solidity uses C3 linearization to resolve inheritance. The order is Child -> B -> C -> A. Calling super.getValue() in Child calls B's getValue(), which calls C's getValue(), which calls A's getValue(). The concatenation results in "BCA".

🔧 Debug

advanced

Identify the error in multiple inheritance override

What error will this Solidity code produce when compiled?

Blockchain / Solidity

pragma solidity ^0.8.0;

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

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

contract Z is X, Y {
    function foo() public pure override returns (string memory) {
        return super.foo();
    }
}

A Compilation error: function foo must override both X and Y

B Runtime error: super.foo() is ambiguous

C Compilation error: override specifier missing base contracts

D No error, outputs "X"

💡 Hint

Check the override keyword and which base contracts are specified.

In Solidity, when overriding a function from multiple base contracts, you must specify all base contracts in the override keyword. Here, override() is missing the base contracts X and Y, causing a compilation error.

📝 Syntax

advanced

Correct syntax for multiple inheritance constructor call

Which option correctly calls constructors of both parents in Solidity?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract A {
    uint public a;
    constructor(uint _a) {
        a = _a;
    }
}

contract B {
    uint public b;
    constructor(uint _b) {
        b = _b;
    }
}

contract Child is A, B {
    constructor(uint _a, uint _b) A(_a) B(_b) {
    }
}

A constructor(uint _a, uint _b) A(_a) { B(_b); }

B constructor(uint _a, uint _b) { A(_a); B(_b); }

C constructor(uint _a, uint _b) { super(_a, _b); }

D constructor(uint _a, uint _b) A(_a) B(_b) {}

💡 Hint

Parent constructors are called in the inheritance list after the constructor signature.

In Solidity, parent constructors are called in the constructor header using the syntax ParentName(args). Option D correctly calls both A and B constructors. Options B and D try to call constructors inside the body, which is invalid. Option D tries to call super with two arguments, which is invalid.

🚀 Application

expert

Determine final state after multiple inheritance function calls

Given these contracts, what is the value of counter after calling Child.increment() once?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract CounterA {
    uint public counter;
    function increment() public virtual {
        counter += 1;
    }
}

contract CounterB {
    uint public counter;
    function increment() public virtual {
        counter += 10;
    }
}

contract Child is CounterA, CounterB {
    function increment() public override(CounterA, CounterB) {
        CounterA.increment();
        CounterB.increment();
    }
}

A Compilation error due to duplicate state variables

B 11

C 1

D 10

💡 Hint

Check how Solidity handles state variables with the same name in multiple inheritance.

Solidity does not allow multiple base contracts to have state variables with the same name because it causes storage layout conflicts. This code will fail to compile due to duplicate 'counter' variables in CounterA and CounterB.

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