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.