Interfaces in Blockchain / Solidity - Mini Project: Build & Apply

Understanding Interfaces in Blockchain Smart Contracts

📖 Scenario: You are building a simple blockchain smart contract system where different contracts must follow a common set of rules. Interfaces help define these rules so that contracts can interact smoothly.

🎯 Goal: Create an interface called ICounter with a function to get the current count and a function to increment the count. Then, create a contract Counter that implements this interface. Finally, display the count after incrementing it.

📋 What You'll Learn

Create an interface named ICounter with two functions: getCount() and increment()

Create a contract named Counter that implements the ICounter interface

Implement the getCount() function to return the current count

Implement the increment() function to increase the count by 1

Display the count after calling increment()

💡 Why This Matters

🌍 Real World

Interfaces are used in blockchain to ensure different smart contracts follow the same rules, making them compatible and easier to interact with.

💼 Career

Understanding interfaces is essential for blockchain developers to build modular, maintainable, and interoperable smart contracts.

1

Create the ICounter interface

Write an interface called ICounter with two function declarations: getCount() that returns a uint and increment() that returns nothing.

Blockchain / Solidity

// Define the ICounter interface with getCount and increment functions
// Your code here

Hint

Interfaces only declare function signatures without any code inside.

2

Create the Counter contract implementing ICounter

Create a contract named Counter that implements the ICounter interface. Inside, declare a private uint variable called count initialized to 0.

Blockchain / Solidity

interface ICounter {
    function getCount() external view returns (uint);
    function increment() external;
}

// Create contract Counter implementing ICounter
// Your code here

Hint

Use is keyword to implement an interface in Solidity.

3

Implement the interface functions in Counter

Inside the Counter contract, implement the getCount() function to return the current count and the increment() function to add 1 to count.

Blockchain / Solidity

interface ICounter {
    function getCount() external view returns (uint);
    function increment() external;
}

contract Counter is ICounter {
    uint private count = 0;

    // Implement getCount and increment functions
    // Your code here
}

Hint

Remember to mark getCount() as view because it does not change state.

4

Call increment() and display the count

Add a function test() in the Counter contract that calls increment() and then returns the current count by calling getCount(). This will show the count after incrementing.

Blockchain / Solidity

interface ICounter {
    function getCount() external view returns (uint);
    function increment() external;
}

contract Counter is ICounter {
    uint private count = 0;

    function getCount() external view returns (uint) {
        return count;
    }

    function increment() external {
        count += 1;
    }

    // Add test function to call increment and return count
    // Your code here
}

Hint

This function helps verify that increment works by returning the updated count.

Practice

1.

What is the main purpose of an interface in blockchain smart contracts?

easy

A. To define a set of function signatures without implementation

B. To store data variables for the contract

C. To execute transactions automatically

D. To create user interfaces for blockchain apps

Solution

1. Step 1: Understand what an interface is

   An interface only declares function names and their inputs/outputs but does not provide code inside them.

2. Step 2: Identify the purpose in blockchain contracts

   Interfaces ensure different contracts agree on function names and types to interact properly.

3. Final Answer:

   To define a set of function signatures without implementation -> Option A

4. Quick Check:

   Interface = function signatures only [OK]

Hint: Interfaces declare functions without code to ensure consistency [OK]

Common Mistakes:

• Thinking interfaces store data variables
• Confusing interfaces with executable code
• Believing interfaces create UI elements

2.

Which of the following is the correct syntax to declare an interface named IPayment in Solidity?

?

easy

A. interface IPayment { function pay() external; }

B. contract IPayment { function pay() public {} }

C. interface IPayment { function pay() public {} }

D. contract IPayment { function pay() external; }

Solution

1. Step 1: Recall interface syntax in Solidity

   Interfaces use the keyword interface and declare functions without bodies, marked external.

2. Step 2: Check each option

   interface IPayment { function pay() external; } correctly declares an interface with an external function without implementation. Versions using contract are wrong. interface IPayment { function pay() public {} } has a function body which is not allowed in interfaces.

3. Final Answer:

   interface IPayment { function pay() external; } -> Option A

4. Quick Check:

   Interface + external function + no body = correct syntax [OK]

Hint: Interfaces use 'interface' keyword and external functions without bodies [OK]

Common Mistakes:

• Using 'contract' instead of 'interface'
• Adding function bodies inside interfaces
• Using 'public' instead of 'external' in interface functions

3.

Given the interface and contract below, what will be the output when calling getValue()?

interface IValue {
    function getValue() external view returns (uint);
}

contract Value is IValue {
    function getValue() external pure returns (uint) {
        return 42;
    }
}

medium

A. 42

B. 0

C. Runtime error

D. Compilation error

Solution

1. Step 1: Compare function signatures in interface and contract

   The interface declares getValue() as view, but the contract implements it as pure. These must match exactly.

2. Step 2: Understand Solidity rules for interface implementation

   Function modifiers like view and pure must match. Mismatch causes a compilation error.

3. Final Answer:

   Compilation error -> Option D

4. Quick Check:

   Modifier mismatch = compilation error [OK]

Hint: Function modifiers must match exactly in interface and implementation [OK]

Common Mistakes:

• Ignoring function modifier differences
• Assuming pure and view are interchangeable
• Expecting runtime error instead of compile error

4.

Identify the error in the following Solidity code implementing an interface:

interface ICalculator {
    function add(uint a, uint b) external returns (uint);
}

contract Calculator is ICalculator {
    function add(uint a, uint b) public returns (uint) {
        return a + b;
    }
}

medium

A. Contract should not use 'is' keyword

B. Function visibility mismatch between interface and contract

C. Interface cannot have functions with parameters

D. Missing function body in contract

Solution

1. Step 1: Check function visibility in interface and contract

   The interface function is declared as external, but the contract function is public. These must match.

2. Step 2: Understand Solidity interface implementation rules

   Function visibility must be the same; otherwise, it causes a compilation error.

3. Final Answer:

   Function visibility mismatch between interface and contract -> Option B

4. Quick Check:

   Visibility mismatch = compilation error [OK]

Hint: Match function visibility exactly between interface and contract [OK]

Common Mistakes:

• Using public instead of external in implementation
• Thinking interfaces cannot have parameters
• Ignoring 'is' keyword for inheritance

5.

You want to create a contract Token that implements two interfaces IERC20 and IERC721. Which of the following is the correct way to declare this contract?

hard

A. interface Token is IERC20, IERC721 { /* implementation */ }

B. contract Token implements IERC20, IERC721 { /* implementation */ }

C. contract Token is IERC20, IERC721 { /* implementation */ }

D. contract Token inherits IERC20, IERC721 { /* implementation */ }

Solution

1. Step 1: Recall Solidity syntax for multiple interface inheritance

   Solidity uses the keyword is to inherit from multiple interfaces or contracts.

2. Step 2: Evaluate each option

   contract Token is IERC20, IERC721 { /* implementation */ } correctly uses is with both interfaces. contract Token implements IERC20, IERC721 { /* implementation */ } uses implements which is invalid in Solidity. interface Token is IERC20, IERC721 { /* implementation */ } declares Token as an interface, not a contract. contract Token inherits IERC20, IERC721 { /* implementation */ } uses inherits which is not a Solidity keyword.

3. Final Answer:

   contract Token is IERC20, IERC721 { /* implementation */ } -> Option C

4. Quick Check:

   Use 'is' for multiple interface inheritance [OK]

Hint: Use 'is' keyword to inherit multiple interfaces in Solidity [OK]

Common Mistakes:

• Using 'implements' instead of 'is'
• Declaring contract as interface by mistake
• Using non-existent keywords like 'inherits'