Smart Contracts

Smart Contracts

A smart contract is a self-executing program stored on a blockchain that automatically enforces the terms of an agreement when predefined conditions are met. They are the building blocks of decentralized applications.

Smart Contract vs Traditional Contract

  Traditional Contract:           Smart Contract:
  ┌──────────────────────┐       ┌──────────────────────┐
  │  Written agreement   │       │  Code on blockchain  │
  │  Enforced by lawyers │       │  Enforced by code    │
  │  Slow settlement     │       │  Instant execution   │
  │  Trust required      │       │  Trustless           │
  │  Can be disputed     │       │  Tamper-proof        │
  │  Private             │       │  Transparent         │
  └──────────────────────┘       └──────────────────────┘

How Smart Contracts Work

  ┌────────────────────────────────────────────┐
  │  1. Developer writes contract in Solidity  │
  │         │                                  │
  │         ▼                                  │
  │  2. Contract compiled to EVM bytecode      │
  │         │                                  │
  │         ▼                                  │
  │  3. Contract deployed to blockchain       │
  │     (gets a unique address)               │
  │         │                                  │
  │         ▼                                  │
  │  4. Users interact by sending transactions│
  │         │                                  │
  │         ▼                                  │
  │  5. Contract code executes automatically  │
  │         │                                  │
  │         ▼                                  │
  │  6. State changes recorded on-chain       │
  │     (permanent and transparent)           │
  └────────────────────────────────────────────┘

Example: Simple Escrow Contract

  // SPDX-License-Identifier: MIT
  pragma solidity ^0.8.20;

  contract Escrow {
      address public buyer;
      address public seller;
      uint256 public amount;
      bool public released;

      constructor(address _seller) payable {
          buyer = msg.sender;
          seller = _seller;
          amount = msg.value;
      }

      function releaseFunds() public {
          require(msg.sender == buyer, "Only buyer");
          require(!released, "Already released");
          released = true;
          payable(seller).transfer(amount);
      }

      function refund() public {
          require(msg.sender == seller, "Only seller");
          require(!released, "Already released");
          released = true;
          payable(buyer).transfer(amount);
      }
  }

Properties of Smart Contracts

Deterministic: Same input always produces same output across all nodes.

Immutable: Once deployed, code cannot be changed (unless upgrade pattern is built in).

Transparent: Anyone can inspect the code and verify its behavior.

Autonomous: No human intervention needed once conditions are met.