Since Bitcoin's introduction in 2008, blockchain has expanded far beyond cryptocurrency, finding promising use cases in supply chain management. Its core traits—decentralization, immutability, and transparency—directly address long-standing issues like information asymmetry, data tampering, and trust gaps in traditional supply chains. Below, we explore these applications in depth with revised Python and Solidity code examples.

Blockchain in Supply Chain: Key Advantages

1. End-to-End Transparency: Every participant accesses identical transaction and process records, eliminating hidden gaps.
2. Immutable Records: Once data is stored on the blockchain, it cannot be altered, ensuring data integrity.
3. Full Traceability: Track product origins, processing, and distribution at every stage to verify quality and authenticity.
4. Decentralized Governance: Removes reliance on a single central authority, reducing single-point failure risks and operational bottlenecks.

Supply Chain Blockchain Architecture

A blockchain-based supply chain system consists of nodes representing each stakeholder—producers, logistics providers, warehouses, and retailers. All nodes maintain a synchronized distributed ledger that logs every relevant transaction.

Python Ledger Implementation

Below is a simplified supply chain transaction ledger using Python dataclasses for cleaner structure:

from dataclasses import dataclass
from hashlib import sha256
import time

@dataclass
class LedgerEntry:
    sequence: int
    prior_hash: str
    timestamp: int
    payload: str
    hash: str

def compute_hash(seq: int, prior_hash: str, ts: int, data: str) -> str:
    raw_str = f"{seq}{prior_hash}{ts}{data}"
    return sha256(raw_str.encode("utf-8")).hexdigest()

def initialize_first_entry() -> LedgerEntry:
    ts = int(time.time())
    data = "Initial Ledger Anchor"
    h = compute_hash(0, "0", ts, data)
    return LedgerEntry(0, "0", ts, data, h)

def generate_next_entry(last_entry: LedgerEntry, new_data: str) -> LedgerEntry:
    seq = last_entry.sequence + 1
    ts = int(time.time())
    ph = last_entry.hash
    h = compute_hash(seq, ph, ts, new_data)
    return LedgerEntry(seq, ph, ts, new_data, h)

# Initialize and build the ledger
ledger = [initialize_first_entry()]
last_added = ledger[0]

# Log product movement events
event1 = "Batch B sourced from Organic Farm Co."
new_entry = generate_next_entry(last_added, event1)
ledger.append(new_entry)
last_added = new_entry

event2 = "Batch B processed at Eco Manufacturing Plant"
new_entry = generate_next_entry(last_added, event2)
ledger.append(new_entry)
last_added = new_entry

# Print ledger details
for entry in ledger:
    print(f"Entry #{entry.sequence} [Hash: {entry.hash}]")
    print(f"Prior Hash: {entry.prior_hash}")
    print(f"Timestamp: {entry.timestamp}")
    print(f"Payload: {entry.payload}\n")

Code Breakdown

• LedgerEntry Dataclass: Defines the structure of each ledger entry, including sequence number, previous entry hash, timestamp, payload (transaction data), and current entry hash.
• compute_hash Funciton: Generates a unique SHA-256 hash by concatenating entry attributes, ensuring data consistency.
• initialize_first_entry Function: Creates the initial "anchor" entry for the ledger, with no prior hash.
• generate_next_entry Function: Creates a new entry based on the previous one's state and new transaction data.
• Ledger Initialization and Population: Starts with the anchor entry and adds two product movement events.
• Ledger Display: Prints detailed information about each entry to verify the chain.

Solidity Smart Contract Example

Smart contracts automate supply chain processes by executing predefined terms when conditions are met. Below is a revised Solidity contract for tracking shipments and automtaing payments:

pragma solidity ^0.8.20;

contract TraceableSupply {
    struct Shipment {
        uint256 trackingId;
        string itemName;
        uint256 cost;
        address payable vendor;
        address customer;
        bool isDelivered;
    }

    uint256 public shipmentCount;
    mapping(uint256 => Shipment) public shipments;

    function registerShipment(string memory _itemName, uint256 _cost) public {
        shipmentCount++;
        shipments[shipmentCount] = Shipment(shipmentCount, _itemName, _cost, payable(msg.sender), address(0), false);
    }

    function purchaseShipment(uint256 _trackingId) public payable {
        Shipment storage s = shipments[_trackingId];
        require(msg.value == s.cost, "Incorrect payment amount");
        require(s.vendor != msg.sender, "Vendor cannot purchase their own shipment");
        require(s.customer == address(0), "Shipment already purchased");
        s.customer = msg.sender;
    }

    function confirmReceipt(uint256 _trackingId) public {
        Shipment storage s = shipments[_trackingId];
        require(msg.sender == s.customer, "Only customer can confirm receipt");
        require(!s.isDelivered, "Delivery already confirmed");
        s.isDelivered = true;
        s.vendor.transfer(s.cost);
    }
}

Smart Contract Breakdown

• TraceableSupply Contract and Shipment Struct: Manages shipment records with tracking ID, item name, cost, vendor, customer, and delivery status.
• shipmentCount and shipments Mapping: Tracks the number of shipments and stores each shipment's details.
• registerShipment Function: Allows vendors to list new shipments with item details and cost.
• purchaseShipment Function: Enables customers to purchase shipments by sending the exact cost in Ether.
• confirmReceipt Function: Let customers confirm delivery, automatically transferring payment to the vendor if conditions are met.

Real-World Use Cases

1. Food Safety and Traceability: Major retailers like Walmart use blockchain to log food from farm to shelf. A single scan can verify origin, harvest dates, and storage conditions in seconds—down from days with manual systems.
2. Global Shipping Efficiency: Maersk and IBM developed TradeLens, a blockchain platform that tracks container shipments in real time, reducing paperwork and delays.
3. Supply Chain Finance for SMEs: Chinese tech firm Blue Elephant uses blockchain to validate SME transaction data, enabling banks to offer lower-risk loans based on verified records.