Abstract contracts in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of an abstract contract inheritance

What is the output when deploying and calling getValue() from the ConcreteContract below?

Blockchain / Solidity

abstract contract AbstractContract {
    function getValue() public virtual returns (string memory);
}

contract ConcreteContract is AbstractContract {
    function getValue() public override returns (string memory) {
        return "Hello from Concrete!";
    }
}

A "Hello from Concrete!"

B Compilation error: Missing implementation of getValue

C "Hello from Abstract!"

D Runtime error: Abstract function called

💡 Hint

Remember that abstract contracts require derived contracts to implement abstract functions.

The abstract contract declares getValue as virtual without implementation. ConcreteContract overrides and implements getValue, so calling it returns the implemented string.

🧠 Conceptual

intermediate

Purpose of abstract contracts

What is the main purpose of using abstract contracts in blockchain smart contract development?

A To define a contract with some functions unimplemented, forcing derived contracts to implement them

B To deploy a contract that cannot be inherited

C To create a contract that stores data permanently without functions

D To automatically generate user interfaces for contracts

💡 Hint

Think about contracts that act like blueprints.

Abstract contracts serve as blueprints with function signatures but no implementations, requiring child contracts to provide the actual code.

🔧 Debug

advanced

Identify the error in abstract contract implementation

What error will the Solidity compiler produce for the following code?

Blockchain / Solidity

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

contract Derived is Base {
    // Missing override of foo
}

A RuntimeError: Abstract function called

B TypeError: Derived contract must implement function 'foo()' or be declared abstract

C SyntaxError: Missing semicolon after function declaration

D No error, code compiles successfully

💡 Hint

Check if Derived implements all abstract functions.

Derived inherits an abstract function foo but does not implement it or declare itself abstract, causing a compiler error.

📝 Syntax

advanced

Correct syntax for abstract function declaration

Which option shows the correct syntax to declare an abstract function in Solidity?

A abstract function doSomething() public returns (uint);

B function doSomething() public returns (uint) {}

C function doSomething() public virtual returns (uint);

D function doSomething() public abstract returns (uint) {}

💡 Hint

Abstract functions have no body and use the virtual keyword.

In Solidity, abstract functions are declared with virtual and no body (semicolon at end). The other options are invalid syntax.

🚀 Application

expert

Number of items in a contract inheritance chain

Given the following contracts, how many contracts must be deployed to use FinalContract and call getData() successfully?

Blockchain / Solidity

abstract contract A {
    function getData() public virtual returns (string memory);
}

abstract contract B is A {
    function getData() public virtual override returns (string memory);
}

contract FinalContract is B {
    function getData() public override returns (string memory) {
        return "Data from Final";
    }
}

A No contracts can be deployed because of abstract functions

B Two contracts: A and FinalContract

C Three contracts: A, B, and FinalContract

D Only one contract: FinalContract

💡 Hint

Only concrete contracts can be deployed.

Only FinalContract is concrete and deployable. Abstract contracts A and B cannot be deployed. FinalContract implements all abstract functions.

Practice

1.

What is the main purpose of an abstract contract in blockchain programming?

easy

A. To define functions without implementation that child contracts must complete

B. To deploy a contract directly on the blockchain

C. To store data permanently without functions

D. To create a user interface for blockchain apps

Solution

1. Step 1: Understand abstract contract role

   Abstract contracts declare functions without full code, acting as templates.

2. Step 2: Identify deployment capability

   They cannot be deployed alone but require child contracts to implement missing parts.

3. Final Answer:

   To define functions without implementation that child contracts must complete -> Option A

4. Quick Check:

   Abstract contract = function templates [OK]

Hint: Abstract contracts declare incomplete functions for children [OK]

Common Mistakes:

• Thinking abstract contracts can be deployed directly
• Confusing abstract contracts with interfaces
• Believing abstract contracts store data only

2.

Which of the following is the correct syntax to declare an abstract contract in Solidity?

?

easy

A. contract MyContract abstract { function foo() public; }

B. abstract contract MyContract { function foo() public virtual; }

C. abstract MyContract contract { function foo() public; }

D. contract MyContract { abstract function foo(); }

Solution

1. Step 1: Check abstract contract declaration

   In Solidity, use 'abstract contract' before the contract name.

2. Step 2: Verify function declaration

   Abstract functions are declared with 'virtual' and no body.

3. Final Answer:

   abstract contract MyContract { function foo() public virtual; } -> Option B

4. Quick Check:

   Correct abstract syntax = abstract contract MyContract { function foo() public virtual; } [OK]

Hint: Use 'abstract contract' and 'virtual' for abstract functions [OK]

Common Mistakes:

• Placing 'abstract' after 'contract'
• Missing 'virtual' keyword on abstract functions
• Trying to define function body in abstract contract

3.

Given the following Solidity code, what will be the output when child.getValue() is called?

abstract contract Parent {
    function getValue() public virtual returns (string memory);
}

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

medium

A. Compilation error due to missing function body in Parent

B. "Hello from Parent"

C. "Hello from Child"

D. Runtime error because Parent is abstract

Solution

1. Step 1: Understand abstract function in Parent

   Parent declares getValue() as abstract (no body), so Child must implement it.

2. Step 2: Check Child's implementation

   Child overrides getValue() and returns "Hello from Child" string.

3. Final Answer:

   "Hello from Child" -> Option C

4. Quick Check:

   Child's override runs = "Hello from Child" [OK]

Hint: Child must implement abstract functions; output from child method [OK]

Common Mistakes:

• Expecting Parent's abstract function to run
• Thinking abstract contracts cause runtime errors
• Confusing compilation errors with runtime errors

4.

Identify the error in this Solidity code snippet:

abstract contract Base {
    function doSomething() public virtual;
}

contract Derived is Base {
    // Missing implementation of doSomething
}

medium

A. Derived contract must implement doSomething() or be declared abstract

B. Base contract should not have virtual functions

C. Derived contract cannot inherit from abstract contracts

D. doSomething() must have a function body in Base

Solution

1. Step 1: Check abstract function in Base

   doSomething() is abstract (no body), so Derived must implement it or be abstract.

2. Step 2: Analyze Derived contract

   Derived does not implement doSomething() and is not abstract, causing error.

3. Final Answer:

   Derived contract must implement doSomething() or be declared abstract -> Option A

4. Quick Check:

   Abstract functions require implementation in non-abstract children [OK]

Hint: Non-abstract child must implement all abstract functions [OK]

Common Mistakes:

• Assuming virtual means implemented
• Forgetting to mark Derived as abstract if no implementation
• Thinking abstract contracts can be instantiated

5.

You want to create a contract system where multiple child contracts share a common function signature but implement it differently. How should you design the parent contract?

hard

A. Use an interface with implemented functions

B. Use a regular contract with fully implemented functions

C. Use a library instead of a contract

D. Use an abstract contract with the function declared as virtual and no body

Solution

1. Step 1: Understand shared function signature need

   Multiple children must share function names but implement differently.

2. Step 2: Choose abstract contract design

   Abstract contracts declare functions without bodies, forcing children to implement them.

3. Step 3: Exclude other options

   Regular contracts have implementations, libraries can't enforce function signatures, interfaces can't have implementations.

4. Final Answer:

   Use an abstract contract with the function declared as virtual and no body -> Option D

5. Quick Check:

   Abstract contract enforces function signature for children [OK]

Hint: Abstract contracts enforce shared function signatures [OK]

Common Mistakes:

• Using regular contracts which fix implementation
• Confusing interfaces with implemented functions
• Trying to use libraries for function enforcement