How Blockchain Works in Real Companies

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

/// @title Provenance
/// @notice Records the chain of custody for a physical product.
/// @dev Deployed on a permissioned chain (Quorum/Besu or Polygon)
///      where only approved manufacturers, shippers, and retailers
///      can write. Reads are restricted by role.

contract Provenance {
    enum Stage { Manufactured, InTransit, Customs, Delivered, Recalled }

    struct Checkpoint {
        Stage stage;
        string location;
        address actor;
        uint256 timestamp;
        string documentHash;   // hash of an off-chain document
    }

    mapping(bytes32 => Checkpoint[]) private history;
    mapping(address => bool) public isAuthorized;

    address public admin;
    uint256 public checkpointCount;

    event CheckpointRecorded(
        bytes32 indexed productId,
        Stage stage,
        address indexed actor,
        uint256 timestamp
    );

    modifier onlyAuthorized() {
        require(isAuthorized[msg.sender], "Not an authorized party");
        _;
    }

    constructor() {
        admin = msg.sender;
        isAuthorized[msg.sender] = true;
    }

    function authorize(address party) external {
        require(msg.sender == admin, "Admin only");
        isAuthorized[party] = true;
    }

    function revoke(address party) external {
        require(msg.sender == admin, "Admin only");
        isAuthorized[party] = false;
    }

    function record(
        bytes32 productId,
        Stage stage,
        string calldata location,
        string calldata documentHash
    ) external onlyAuthorized {
        history[productId].push(Checkpoint({
            stage: stage,
            location: location,
            actor: msg.sender,
            timestamp: block.timestamp,
            documentHash: documentHash
        }));
        checkpointCount++;
        emit CheckpointRecorded(productId, stage, msg.sender, block.timestamp);
    }

    function getHistory(bytes32 productId)
        external
        view
        returns (Checkpoint[] memory)
    {
        return history[productId];
    }
}

// What enterprise interviewers look for:
// - Only authorized parties can write — this is the whole point
//   of a permissioned network.
// - Every checkpoint records WHO, WHERE, WHEN, and a hash of
//   the supporting document.
// - The on-chain record is a hash, not the document itself —
//   PII and business data stay off-chain.
// - Events are emitted for off-chain indexing and monitoring.
// - The contract is small and readable — not a monolith.
//
// Why companies do this:
// - A recalled batch can be traced to the exact stage and location.
// - Regulators get an immutable audit trail.
// - No single party can rewrite history.

// pharmacyChaincode.js — a Hyperledger Fabric chaincode for
// pharmaceutical serialisation.
// This is what a real permissioned-network contract looks like.

'use strict';

const { Contract } = require('fabric-contract-api');

class PharmacyChain extends Contract {

  async initLedger(ctx) {
    await ctx.stub.putState('INIT', Buffer.from('PharmacyChain v1'));
  }

  // Register a drug unit at the manufacturer.
  async registerUnit(ctx, serialNo, productId, batchId, expiry) {
    const exists = await this.unitExists(ctx, serialNo);
    if (exists) throw new Error(`Unit ${serialNo} already exists`);

    const unit = {
      serialNo,
      productId,
      batchId,
      expiry,
      status: 'MANUFACTURED',
      location: 'manufacturer',
      history: [{
        status: 'MANUFACTURED',
        actor: ctx.clientIdentity.getID(),
        timestamp: new Date().toISOString(),
      }],
    };

    await ctx.stub.putState(serialNo, Buffer.from(JSON.stringify(unit)));
    return JSON.stringify(unit);
  }

  // Record a handoff between parties (wholesaler, pharmacy, etc.)
  async transfer(ctx, serialNo, newLocation, newStatus) {
    const bytes = await ctx.stub.getState(serialNo);
    if (!bytes || bytes.length === 0) {
      throw new Error(`Unit ${serialNo} does not exist`);
    }

    const unit = JSON.parse(bytes.toString());

    if (unit.status === 'DISPENSED') {
      throw new Error(`Unit ${serialNo} has already been dispensed`);
    }

    unit.status = newStatus;
    unit.location = newLocation;
    unit.history.push({
      status: newStatus,
      actor: ctx.clientIdentity.getID(),
      timestamp: new Date().toISOString(),
    });

    await ctx.stub.putState(serialNo, Buffer.from(JSON.stringify(unit)));
    return JSON.stringify(unit);
  }

  async verify(ctx, serialNo) {
    const bytes = await ctx.stub.getState(serialNo);
    if (!bytes || bytes.length === 0) {
      return JSON.stringify({ valid: false, reason: 'not_found' });
    }
    const unit = JSON.parse(bytes.toString());
    return JSON.stringify({
      valid: unit.status !== 'RECALLED',
      status: unit.status,
      location: unit.location,
      history: unit.history,
    });
  }

  async unitExists(ctx, serialNo) {
    const bytes = await ctx.stub.getState(serialNo);
    return bytes && bytes.length > 0;
  }
}

module.exports = PharmacyChain;

// What enterprise interviewers look for:
// - State is stored per unit — the serial number is the key.
// - Every mutation appends to an immutable history.
// - Identity comes from the network (clientIdentity), not the
//   request body — the whole point of permissioning.
// - Business rules are enforced in code (can't dispense twice).
// - Recalled units are flagged, not deleted.
//
// Why this is Fabric, not Solidity:
// - Fabric's chaincode model fits a regulated supply chain
//   better than public contracts.
// - Channels keep each participant's data private.
// - Identity is managed by the consortium's certificate authority.

// readLedger.js — how a company actually reads from an
// enterprise blockchain in a backend service.

// This example uses ethers.js against a permissioned EVM chain
// (Quorum/Besu). The same pattern works for Fabric with the
// Fabric SDK — the shape is always: connect, query, transform.

const { ethers } = require('ethers');

const PROVIDER_URL = 'https://rpc.enterprise-chain.internal';
const CONTRACT_ADDRESS = '0xYourContractAddress';
const ABI = [
  'function checkpointCount() view returns (uint256)',
  'function getHistory(bytes32 productId) view returns (tuple(uint8 stage, string location, address actor, uint256 timestamp, string documentHash)[])',
];

async function getProvenance(productId) {
  const provider = new ethers.JsonRpcProvider(PROVIDER_URL);
  const contract = new ethers.Contract(CONTRACT_ADDRESS, ABI, provider);

  const history = await contract.getHistory(productId);
  const count = await contract.checkpointCount();

  return {
    productId,
    checkpoints: history.map((c) => ({
      stage: ['Manufactured', 'InTransit', 'Customs', 'Delivered', 'Recalled'][c.stage],
      location: c.location,
      actor: c.actor,
      timestamp: new Date(Number(c.timestamp) * 1000).toISOString(),
      documentHash: c.documentHash,
    })),
    totalCheckpointsOnChain: Number(count),
  };
}

async function main() {
  const productId = ethers.id('BATCH-2026-0912-A');
  const result = await getProvenance(productId);
  console.log(JSON.stringify(result, null, 2));
}

main().catch((err) => {
  console.error('Ledger read failed:', err.message);
  process.exit(1);
});

// What enterprise interviewers look for:
// - The service reads from the chain — it does not write.
//   Writing happens inside the authorized app, not here.
// - The output is clean, structured data that can go straight
//   into an internal API or dashboard.
// - Errors are handled — the ledger may be unavailable, and
//   that must not crash the whole product.
// - The provider URL is internal — this is a permissioned
//   network, not a public RPC endpoint.
//
// Why companies need this layer:
// - The chain is not user-friendly. Business apps need a
//   clean REST or GraphQL API on top of it.
// - This is where "blockchain engineer" meets "backend
//   engineer" — and where most enterprise blockchain jobs
//   actually live.