Why Abstract contracts in Blockchain / Solidity? - Purpose & Use Cases

The Big Idea

What if you could write shared contract rules once and never repeat yourself again?

The Scenario

Imagine building a complex blockchain app where many contracts share similar rules but have different details. Without abstract contracts, you must rewrite the same code again and again for each contract.

The Problem

Manually copying code leads to mistakes, inconsistencies, and makes updates a nightmare. If you fix a bug in one place, you must remember to fix it everywhere else. This wastes time and causes errors.

The Solution

Abstract contracts let you write shared rules once as a blueprint. Other contracts then fill in the details. This keeps code clean, consistent, and easy to update.

Before vs After

✗ Before

contract Token {
  function transfer(address to, uint amount) public {}
}

contract MyToken {
  function transfer(address to, uint amount) public {}
}

✓ After

abstract contract Token {
  function transfer(address to, uint amount) public virtual;
}

contract MyToken is Token {
  function transfer(address to, uint amount) public override {}
}

What It Enables

It enables building flexible, reusable contract systems that are easier to maintain and less error-prone.

Real Life Example

Think of a banking system where different accounts share common rules like deposit and withdraw, but each account type has its own special rules. Abstract contracts let you define the common rules once and customize each account type easily.

Key Takeaways

Abstract contracts define shared rules without full details.

They prevent code duplication and reduce errors.

They make blockchain apps easier to build and maintain.