Interfaces in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - Interfaces

Define Interface

↓

Declare Functions (no body)

↓

Implement Interface in Contract

↓

Provide Function Bodies

↓

Use Contract via Interface Reference

↓

Call Functions as Defined

Interfaces define function signatures without code. Contracts implement these functions. Then, contracts can be used through the interface.

Execution Sample

Blockchain / Solidity

interface IToken {
  function transfer(address to, uint256 amount) external;
}

contract MyToken is IToken {
  function transfer(address to, uint256 amount) external override {
    // transfer logic
  }
}

Defines an interface IToken with a transfer function, then a contract MyToken implements it with actual code.

Execution Table

Step	Action	Evaluation	Result
1	Define interface IToken with transfer function	No function body	Interface created with function signature
2	Define contract MyToken implementing IToken	Must implement transfer	Contract MyToken created
3	Implement transfer function in MyToken	Function body provided	MyToken now has transfer logic
4	Deploy MyToken contract	Contract deployed on blockchain	MyToken instance ready
5	Call transfer via IToken interface reference	Calls MyToken.transfer	Transfer logic executed
6	End of execution	All interface functions implemented and callable	Execution complete

💡 All interface functions are implemented; contract is deployed and callable

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
IToken Interface	undefined	defined	defined	defined
MyToken Contract	undefined	defined (with code)	deployed instance	deployed instance
transfer function	undefined	implemented	ready to call	ready to call

Key Moments - 3 Insights

Why can't we put code inside interface functions?

Interfaces only declare function signatures without bodies, as shown in execution_table step 1, so contracts can implement them differently.

What happens if MyToken does not implement all interface functions?

The contract will not compile or deploy, because as in step 2 and 3, all interface functions must be implemented.

How do we call functions using the interface?

We use the interface type to reference the contract, then call functions as in step 5, ensuring only declared functions are accessible.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the transfer function implemented with code?

A Step 5

B Step 1

C Step 3

D Step 2

💡 Hint

Check the 'Action' and 'Result' columns at step 3 in the execution_table

According to variable_tracker, when is the MyToken contract deployed?

A After Step 3

B After Step 4

C At Start

D After Final

💡 Hint

Look at the 'MyToken Contract' row and the 'After Step 4' column in variable_tracker

If we remove the transfer function implementation in MyToken, what happens?

A Contract fails to compile or deploy

B Contract deploys successfully

C Interface functions are optional

D Interface automatically provides default code

💡 Hint

Refer to key_moments about implementation requirements and execution_table steps 2 and 3

Concept Snapshot

Interfaces declare function signatures without code.
Contracts must implement all interface functions.
Use interface type to interact with contracts.
Interfaces ensure consistent function names and parameters.
They help separate definition from implementation.

Full Transcript

Interfaces in blockchain programming define function signatures without any code. This means they only say what functions exist and their inputs and outputs, but not how they work. Contracts then implement these interfaces by writing the actual code for each function. The flow starts by defining the interface, then creating a contract that implements it, providing function bodies. After deployment, the contract can be used through the interface reference, calling the implemented functions. This ensures that any contract following the interface has the same function names and parameters, making interaction predictable and standardized. If a contract does not implement all interface functions, it will not compile or deploy. Calling functions via the interface type restricts access to only those declared in the interface, improving safety and clarity.