Skip to content

Home

Jump to bottom
ABDUL HAIY edited this page Mar 19, 2026 · 6 revisions 
                    # CHAINFAIR - PROJECT OVERVIEW
       Agricultural Supply Chain Transparency on the Blockchain
           Built for Hackathonomics 2026 | Team ChainFair

TABLE OF CONTENTS

  1. What is ChainFair?
  2. The Problem We Solve
  3. Core Project Philosophy
  4. System Architecture
  5. Smart Contract (SupplyChain.sol)
  6. Deployment Script (deploy.js)
  7. Smart Contract Tests (test/SupplyChain.js)
  8. React Native Consumer App (frontend/app/App.js)
  9. Next.js Admin Dashboard (dashboard/)
  10. Web Viewer (web-app/index.html)
  11. Demo Data & Supply Chain Examples
  12. How to Run the Entire Stack
  13. How the Pieces Connect (Data Flow)
  14. Blockchain & IPFS Integration
  15. Multilingual Support (English / Hindi)
  16. Security & Access Control
  17. Gas Optimization
  18. Hackathon Criteria Alignment
  19. Environment Variables Reference
  20. File Structure Reference

1. WHAT IS CHAINFAIR?

ChainFair is a decentralized application (DApp) that brings radical transparency to agricultural supply chains in India. When a consumer picks up a mango at a store in Mumbai, they have no idea how much of the ₹200 price actually reached the farmer in Jabalpur who grew it.

ChainFair solves this by recording every step of the supply chain—from farm to store—on the Polygon blockchain. Each QR code on a product, when scanned, instantly reveals the full profit split across all actors: farmer, wholesaler, retailer, and store.

The project includes:

  • A Solidity smart contract (the "single source of truth")
  • A React Native mobile app for consumers to scan QR codes
  • A Next.js admin dashboard for farmers and retailers to register stages
  • A standalone web viewer for browser-based demos
  • IPFS integration for storing farm photos and certifications off-chain

2. THE PROBLEM WE SOLVE

India has 600+ million people dependent on agriculture, yet:

  • Farmers receive only 10-15% of the final consumer price
  • 3-4 middlemen each take 15-30% margins
  • Consumers have no way to verify "fair trade" claims
  • Farmers have no bargaining power because they can't see market prices

EXAMPLE (Jabalpur Mango): Farm (Jabalpur) → Farmer earns: ₹20 Wholesaler (Local) → Sold at: ₹60 (+₹40 markup) Retailer (City) → Sold at: ₹120 (+₹60 markup) Store (Consumer) → Final Price: ₹200 (+₹80 markup)

The farmer gets just 10% of the final price, but has no visibility into why. ChainFair puts that data on an immutable blockchain and makes it scannable.

3. CORE PROJECT PHILOSOPHY

  • IMMUTABILITY: Once recorded on blockchain, no one can alter stage data.
  • TRANSPARENCY: Every consumer can see every rupee's journey.
  • EDUCATION: Showing data is not enough; we explain WHY it is this way.
  • ACCESSIBILITY: Works on Expo (mobile), web browser, or Next.js dashboard.
  • LOW COST: Uses Polygon Mumbai testnet (<$0.01 per transaction).
  • PRIVACY-FIRST: Farmers opt-in; no personal data stored on-chain.

4. SYSTEM ARCHITECTURE

                    CONSUMER (Scans QR)
                           |
                   React Native App
                 (frontend/app/App.js)
                           |
                ethers.js / MetaMask
                           |
      ┌────────────────────▼────────────────────┐
      │     POLYGON MUMBAI TESTNET              │
      │     SupplyChain.sol (Smart Contract)    │
      │     - createChain()                     │
      │     - addStage()                        │
      │     - getChain()                        │
      │     - getChainProfitSplit()             │
      └────────────────────┬────────────────────┘
                           │
                ┌──────────▼──────────┐
                │   IPFS (Pinata)     │
                │ - Farm photos       │
                │ - Certifications    │
                │ (only hashes on     │
                │  blockchain)        │
                └─────────────────────┘

                 ADMIN USERS (Farmers, Retailers)
                           |
               Next.js Dashboard (dashboard/)
                           |
                ethers.js + MetaMask
                           |
                (same smart contract)

5. SMART CONTRACT (contracts/SupplyChain.sol)

Language: Solidity ^0.8.20 Network: Polygon Mumbai Testnet (supports local Hardhat node too)

--- DATA STRUCTURES ---

StageType (Enum):

  • Farm (0), Wholesaler (1), Retailer (2), Store (3)

SupplyStage (Struct):

  • stageType : Which stage (Farm/Wholesale/Retail/Store)
  • actor : Ethereum address of the actor
  • actorName : Human-readable name (e.g., "Jabalpur Wholesale Co.")
  • profitShareBPS : Profit share in Basis Points (10000 = 100%)
  • priceAtStage : Price in Wei at this stage (converted to INR for display)
  • ipfsHash : Hash of IPFS-stored image/document
  • timestamp : When this stage was recorded (block.timestamp)
  • certificationHash: Hash of any certification document
  • isVerified : Whether a trusted actor has verified this stage

ProductChain (Struct):

  • productName : e.g., "Jabalpur Alphonso Mango"
  • origin : e.g., "Jabalpur, Madhya Pradesh"
  • totalPrice : Current consumer price (updates with each stage)
  • farmerPrice : Original price at farm (never changes)
  • stages[] : Array of SupplyStage structs
  • isComplete : Whether chain has been finalized
  • createdAt : Timestamp of chain creation

--- KEY FUNCTIONS ---

authorizeActor(address, name):

  • Only callable by an already-authorized actor
  • Allows addition of new trusted participants (farmers, wholesalers, etc.)

createChain(productName, origin, farmerPrice, ipfsHash, certHash):

  • Creates a new ProductChain entry
  • Automatically adds the first "Farm" stage
  • Returns a tokenId (used for QR codes and lookups)
  • Sets initial profitShareBPS to 10000 (100%) for the farmer stage

addStage(tokenId, stageType, actorName, profitShareBPS, priceAtStage, ipfsHash, certHash):

  • Adds a new stage to an existing chain
  • Price must be >= previous stage price (supply chain prices only increase)
  • profitShareBPS must be <= 10000
  • The actual profit share for a stage means: that actor's MARGIN out of total

verifyStage(tokenId, stageIndex):

  • Marks a stage as verified by a trusted actor
  • Adds credibility to the supply chain record

completeChain(tokenId):

  • Finalizes the chain, preventing further stage additions
  • Emits ChainCompleted event with final consumer price

getChain(tokenId):

  • Returns: productName, origin, totalPrice, farmerPrice, stageCount, isComplete, createdAt

getStage(tokenId, stageIndex):

  • Returns all details of a specific stage in the chain

getFullChain(tokenId):

  • Returns the entire ProductChain struct including all stages

getChainProfitSplit(tokenId):

  • Returns arrays of profitShares and stageNames, plus totalPrice
  • Used by the frontend to draw the pie chart

getFarmerShare(tokenId):

  • Returns: farmerShareBPS, farmerAmountINR, totalAmountINR
  • Gives a quick summary of how much the farmer got

--- EVENTS ---

ChainCreated(tokenId, productName, origin, farmerPrice)

  • Fired when a new product is registered

StageAdded(tokenId, stageType, actor, profitShareBPS, priceAtStage)

  • Fired every time a new middleman stage is added

ChainCompleted(tokenId, totalPrice)

  • Fired when the chain is sealed

ActorAuthorized(actor, actorName)

  • Fired when a new participant is given permission to write to the contract

StageVerified(tokenId, stageIndex)

  • Fired when a stage is marked as trusted/verified

6. DEPLOYMENT SCRIPT (scripts/deploy.js)

Language: JavaScript (Node.js / Hardhat)

What it does when you run it:

  1. Deploys the SupplyChain.sol contract to the chosen network

  2. Prints the deployed contract address (SAVE THIS!)

  3. Authorizes 3 demo actor addresses (wholesaler, retailer, store)

  4. Creates 3 complete demo supply chains with all 4 stages each:

    CHAIN 0 - Jabalpur Alphonso Mango: Farm: ₹20 (Farmer Cooperative, Jabalpur) Wholesale: ₹60 (Jabalpur Wholesale Co.) Retail: ₹120 (City Mart Retail) Store: ₹200 (Fresh Picks Store)

    CHAIN 1 - Jabalpur Organic Tomato: Farm: ₹15 (Local Farmers, Jabalpur) Wholesale: ₹40 (Jabalpur Wholesale Co.) Retail: ₹80 (City Mart Retail) Store: ₹150 (Fresh Picks Store)

    CHAIN 2 - Kashmir Premium Apple: Farm: ₹50 (Kashmir Orchard) Wholesale: ₹100 (Delhi Agricultural Market) Retail: ₹150 (Premium Foods Ltd) Store: ₹300 (Jabalpur Fresh Mart)

  5. Marks all 3 chains as "complete"

  6. If deployed on polygonMumbai, attempts Etherscan verification

How to run: Local: npx hardhat run scripts/deploy.js --network localhost Mumbai: npx hardhat run scripts/deploy.js --network polygonMumbai

7. SMART CONTRACT TESTS (test/SupplyChain.js)

Framework: Chai + Hardhat (ethers.js v6)

Test Suites & What They Test:

"Chain Creation":

  • Verifies correct tokenId assignment (starts at 0)
  • Verifies product name, origin, farmerPrice correctly stored
  • Confirms stageCount = 1 after creation (the Farm stage)

"Stage Addition":

  • Verifies adding a wholesaler stage updates totalPrice
  • Verifies stageCount increments correctly
  • Tests full 4-stage pipeline in sequence
  • Tests that LOWER price in addStage() is correctly REJECTED (prices can only increase along the supply chain)

"Profit Split Calculation":

  • Builds a full Mango chain (₹20 -> ₹200)
  • Calls getFarmerShare() and verifies farmer gets 10000 BPS and the correct amounts in INR

"Chain Completion":

  • Verifies completeChain() sets isComplete = true

"Access Control":

  • Verifies unauthorized addresses CANNOT create chains (expect revert)
  • Verifies authorized addresses CAN create chains (expect no revert)

"Events":

  • Verifies ChainCreated event fires with correct arguments
  • Verifies StageAdded event fires with correct actor address

How to run tests: npx hardhat test

8. REACT NATIVE CONSUMER APP (frontend/app/App.js)

Framework: React Native + Expo SDK Target: iOS, Android, and Web (via expo-start --web)

--- FEATURES ---

A) Language Toggle (English / Hindi):

  • EN button: All text in English
  • हि button: All text in Hindi
  • Hindi translations include: "चेनफेयर" (ChainFair) "QR कोड स्कैन करें" (Scan QR Code) "किसान का हिस्सा" (Farmer Share) "आर्थिक अंतर्दृष्टि" (Economic Insight) ...and all other UI strings

B) QR Code Scanner (Mobile only):

  • Uses expo-camera (CameraView) for live QR scanning
  • Reads three QR formats: chainfair://0 (deeplink format) https://...?tokenId=0 (URL format) 0 (raw integer format)
  • On scan, calls fetchChainData(tokenId)
  • Shows animated scan area with green corner brackets

C) Blockchain Data Fetching:

  • If MetaMask (window.ethereum) is available: Uses ethers.BrowserProvider to connect Calls getChain() and getStage() from the contract ABI Converts Wei prices to INR (multiplied by 1000 for demo scaling)
  • If MetaMask is NOT available (most web users): Falls back to DEMO_CHAINS array with hardcoded local data Allows demo even without wallet

D) Demo Mode (View Demo Data button):

  • Shows a list of 3 pre-loaded demo products
  • Users can tap any product to see the full supply chain view
  • Works on web even without camera or MetaMask
  • Bug fix: State management correctly routes from the web/permission screen through to the demo selector and chain detail views

E) Chain Detail View (after scan or demo select):

  • Product name and origin
  • Farmer Share box: shows ₹ amount + percentage
  • Consumer Price box: shows total price
  • Arrow between the two for visual impact

F) Pie Chart (Profit Breakdown):

  • Uses react-native-chart-kit PieChart
  • 4 slices, color-coded: Green = Farm/Farmer Blue = Wholesaler Orange = Retailer Purple = Store
  • Labeled with stage name + percentage

G) Supply Chain Stages List:

  • Numbered list (1, 2, 3, 4) with colored circle icons
  • Shows: Stage type, actor name, price at stage, share percentage

H) Economic Insight Card:

  • Orange bordered card explaining WHY farmers get less
  • Text adapts to selected language

I) UPI Tip Button:

  • Purple button at the bottom: "Support Fair Trade"
  • Subtext: "Tip the farmer directly via UPI"
  • On press: Alert with demo UPI ID (farmer.jabalpur@upi)
  • In production, this would open the UPI deep link for payment

J) Camera Permission Handling:

  • Requests camera permission before scanning
  • Shows a "Grant Permission" button if denied
  • Falls back to demo mode if permission unavailable

--- CONFIGURATION --- CONTRACT_ADDRESS: Set via EXPO_PUBLIC_CONTRACT_ADDRESS env var or defaults to zero address (triggers demo mode) IPFS_GATEWAY: https://ipfs.io/ipfs/ (for fetching stage images)

9. NEXT.JS ADMIN DASHBOARD (dashboard/)

Framework: Next.js 14 + Tailwind CSS + Recharts + ethers.js

URL: http://localhost:3000 (when running npm run dev)

--- TABS ---

"Overview" Tab:

  • 4 stat cards: Total Chains, Active Farmers, Total Value, Transparency Score
  • Pie chart: Average profit distribution across all chains
  • Line chart: Growth trend (farmers registered + chains created over 6 months)
  • Table: List of recent supply chains with farmer share badges

"Chains" Tab:

  • Card grid showing all registered supply chains
  • Each card: product name, token ID, farmer share badge, stage progress bars
  • Total value displayed at the bottom of each card

"Upload" Tab (Create Supply Chain):

  • Form fields: Product Name, Origin, Farmer Price
  • IPFS file upload area (drag-and-drop style) for farm photos/certs
  • "Create Supply Chain" button
  • BLOCKCHAIN INTEGRATION: Checks if wallet is connected before proceeding Creates a BrowserProvider from window.ethereum (MetaMask) Gets the signer from the provider Calls contract.createChain() with the form data Converts farmer price to Wei using ethers.parseUnits() Waits for transaction confirmation (tx.wait()) Adds new chain to local state on success Shows success/error alerts

"Analytics" Tab:

  • Bar chart: Farmer income distribution across different percentage ranges
  • Circular progress: Chain completion rate (94%)

--- WALLET CONNECTION ---

  • "Connect Wallet" button in the navigation
  • Uses eth_requestAccounts to request MetaMask access
  • Shows truncated address (0x1234...5678) when connected
  • All write operations require wallet to be connected

--- CONTRACT_ABI (defined in dashboard):

  • createChain(...)
  • addStage(...)
  • chainCounter()
  • getChain(...)

10. WEB VIEWER (web-app/index.html)

Type: Standalone HTML file (no build step needed) Usage: Open directly in browser for instant demo

This is a self-contained, single-file web app that replicates the mobile app's consumer experience without requiring Expo or a React build.

--- SCREENS ---

Home Screen:

  • Note saying "Scan QR codes with the mobile app..."
  • "View Demo Data" button (blue)

Demo Selection Screen:

  • Back link
  • List of 3 products (Mango, Tomato, Apple) with prices

Detail Screen:

  • Header: "✓ Verified on Blockchain"
  • Product name + origin
  • Price row: Farmer Share ← arrow → Consumer Price
  • Profit Breakdown section with Canvas-drawn pie chart
  • Supply Chain Stages list (numbered with colored circles)
  • Economic Insight card (orange border)
  • Support Fair Trade card (purple)
  • "Scan Another" button

--- BUILT-IN FEATURES ---

  • Canvas-drawn donut pie chart (no library needed)
  • Legend with color-coded stage names
  • Multilingual toggle (EN / हि) - same translations as mobile app
  • updateTexts() function re-renders all text on language switch
  • Pure vanilla JavaScript, zero dependencies

11. DEMO DATA & SUPPLY CHAIN EXAMPLES

All three demo chains are consistent across all components of the project:

CHAIN ID 0: Jabalpur Alphonso Mango Farmer: Farmer Cooperative, Jabalpur ₹20 (10%) Wholesaler: Jabalpur Wholesale ₹60 (20% margin) Retailer: City Mart ₹120 (30% margin) Store: Fresh Picks ₹200 (40% margin) → Farmer receives 10% of consumer price

CHAIN ID 1: Jabalpur Organic Tomato Farmer: Local Farmers, Jabalpur ₹15 (10%) Wholesaler: Jabalpur Wholesale ₹40 (17% margin) Retailer: City Mart ₹80 (27% margin) Store: Fresh Picks ₹150 (46% margin) → Farmer receives 10% of consumer price

CHAIN ID 2: Kashmir Premium Apple Farmer: Kashmir Orchard ₹50 (17%) Wholesaler: Delhi Agricultural Market ₹100 (17% margin) Retailer: Premium Foods Ltd ₹150 (17% margin) Store: Jabalpur Fresh Mart ₹300 (49% margin) → Farmer receives 17% of consumer price (better transparency)

12. HOW TO RUN THE ENTIRE STACK

STEP 1 - Start Local Blockchain (Terminal 1) cd f:\PLAYGROUND\project npx hardhat node (Keep this running. It starts a local Ethereum-like blockchain at port 8545)

STEP 2 - Deploy Contract + Demo Data (Terminal 2) cd f:\PLAYGROUND\project npx hardhat run scripts/deploy.js --network localhost *** COPY THE CONTRACT ADDRESS FROM OUTPUT *** (e.g., "SupplyChain deployed to: 0x5FbDB2315678...")

STEP 3 - Update Contract Address (in 2 files) File 1: f:\PLAYGROUND\project\dashboard\src\pages\index.js (line ~10) File 2: f:\PLAYGROUND\project\frontend\app\App.js (line ~147) Replace the placeholder with your copied address.

STEP 4 - Run Admin Dashboard (Terminal 3) cd f:\PLAYGROUND\project\dashboard npm run dev Visit: http://localhost:3000 Connect MetaMask to Localhost 8545 (Chain ID: 31337)

STEP 5 - Run Consumer Mobile App (Terminal 4) cd f:\PLAYGROUND\project\frontend\app npx expo start Press 'w' for web, or scan the Expo QR code with Expo Go on your phone

STEP 6 (Optional) - View Standalone Web Demo Open: f:\PLAYGROUND\project\web-app\index.html in any browser No setup needed. Click "View Demo Data" for instant demo.

STEP 7 (Optional) - Run Tests cd f:\PLAYGROUND\project npx hardhat test

13. HOW THE PIECES CONNECT (DATA FLOW)

ADMIN ADDING A PRODUCT (Dashboard → Blockchain):

  1. Admin logs into dashboard, connects MetaMask
  2. Fills in product name, origin, farmer price in "Upload" tab
  3. Uploads image to IPFS (returns IPFS hash)
  4. Clicks "Create Supply Chain"
  5. Dashboard calls contract.createChain() with IPFS hash
  6. MetaMask prompts for transaction signature
  7. Transaction confirmed on Polygon Mumbai
  8. Dashboard shows new entry in the "Chains" tab

CONSUMER SCANNING A PRODUCT (App → Blockchain):

  1. Consumer opens the Expo app in a store
  2. Camera scans QR code on produce label
  3. App parses tokenId from QR data (e.g., chainfair://0 → tokenId=0)
  4. App calls contract.getChain(0) to get product metadata
  5. App calls contract.getStage(0, i) for each stage
  6. App renders the pie chart and stage breakdown
  7. Consumer taps "Support Fair Trade" to tip farmer via UPI

WITHOUT METAMASK (Demo Mode):

  1. App detects no window.ethereum
  2. Falls back to local DEMO_CHAINS array
  3. All visualizations still work, just with hardcoded data
  4. Works offline and without any blockchain setup

14. BLOCKCHAIN & IPFS INTEGRATION

BLOCKCHAIN (Polygon Mumbai Testnet):

  • Why Polygon? Transactions cost < $0.01, ideal for frequent supply chain updates
  • Why Mumbai? Free testnet MATIC available via faucets for development
  • Hardhat is used for local development and testing
  • ethers.js v6 is used for all contract interactions
  • All prices stored in Wei (1 ether = 1000 INR in demo scaling)

IPFS (InterPlanetary File System):

  • Off-chain storage of large files (farm photos, certifications)
  • Only the IPFS hash (content identifier / CID) is stored on-chain
  • This keeps contract storage costs low
  • Images fetched via public IPFS gateway: https://ipfs.io/ipfs/{hash}
  • Production would use Pinata or nft.storage for pinning
  • Example CID: QmXoypizjW3WknFiJnKLwHCnL72vedxjQkDDP1mXWo6uco

QR CODE FORMAT: The QR code on produce encodes the tokenId in one of three formats: chainfair://0 (preferred deeplink format) https://app.chainfair.io?tokenId=0 (web-compatible) 0 (raw integer, simplest format) The app's QR scanner handles all three.

15. MULTILINGUAL SUPPORT (ENGLISH / HINDI)

Both the React Native app and the web viewer support English and Hindi. The dashboard is English-only (intended for tech-savvy admin users).

Hindi translations cover all consumer-facing text in the mobile app:

  • App title and subtitle
  • All button labels
  • Stage type names (Farm/Farmer → किसान, Wholesaler → थोक व्यापारी, etc.)
  • Price labels and section headers
  • The economic insight explanation paragraph
  • UPI tip button text

How it works (App.js): const [language, setLanguage] = useState('en'); const t = translations[language]; // Active translation object {t.scanQR} // Renders in selected language

Language toggle is always visible in the top bar (EN | हि buttons).

16. SECURITY & ACCESS CONTROL

The contract uses a simple allowlist pattern:

  • mapping(address => bool) public authorizedActors
  • The deployer is automatically authorized in the constructor
  • Only authorized addresses can: createChain, addStage, verifyStage, completeChain
  • Unauthorized calls revert with "Not authorized"
  • authorizeActor() can only be called by an already-authorized actor

Why not OpenZeppelin's Ownable?

  • The multi-role design (farmers, wholesalers, retailers all need write access) requires a flexible allowlist rather than a single owner pattern.

Ethical considerations:

  • Farmer data is anonymized (only an Ethereum address is stored, not name/ID)
  • Participation is opt-in (farmers must be authorized by a trusted party)
  • Historical data is immutable—actors cannot modify past entries

17. GAS OPTIMIZATION

  • Basis Points (BPS) are used for profit shares (uint256) instead of floats
  • String data (names, IPFS hashes) stored in structs instead of mappings where possible to minimize slot usage
  • Events are used for logging (cheaper than additional storage)
  • The contract avoids loops in expensive write functions
  • getChainProfitSplit() loops internally but is a view function (no gas)
  • Estimated cost per stage addition: 8,000-12,000 gas ($0.001 on Polygon)

18. HACKATHON CRITERIA ALIGNMENT

RELEVANCY (Economics + Code + Education):

  • Directly addresses a documented economic problem in Indian agriculture
  • Cites NITI Aayog statistics and RBI fintech-agri alignment
  • The educational overlay after each scan teaches economic concepts

TECHNICAL EXECUTION:

  • Full-stack DApp: Solidity + Polygon + IPFS + React Native + Next.js
  • ethers.js v6 with proper BigInt handling
  • Hardhat with chai matchers for thorough testing
  • Expo for cross-platform mobile deployment
  • Tailwind + Recharts for beautiful dashboard UI

IMPACT (Societal value for MSMEs):

  • Targets 600M+ Indians dependent on agriculture
  • Simulates "10x farmer income transparency"
  • Empowers consumers to make fair trade choices
  • Supports MSME farmers against large middlemen

PRESENTATION:

  • Pitch deck included (PITCH_DECK.md)
  • 2-minute pitch script with "Ramesh the Jabalpur farmer" narrative
  • Live demo-ready with hardcoded demo data as fallback
  • Impact metrics cited (847 farmers, ₹12.4L tracked, 94% completion rate)

INNOVATION:

  • First QR-blockchain bridge specifically designed for rural Indian markets
  • Multilingual (Hindi) support for Jabalpur-area users
  • UPI tipping integration for direct farmer support
  • IPFS + Polygon = zero AWS/cloud vendor dependency

19. ENVIRONMENT VARIABLES REFERENCE

Root-level .env (for Hardhat): POLYGON_MUMBAI_RPC=https://rpc-mumbai.maticvigil.com PRIVATE_KEY=0xyour_wallet_private_key_here POLYGONSCAN_API_KEY=your_polygonscan_api_key

dashboard/.env.local (for Next.js): NEXT_PUBLIC_CONTRACT_ADDRESS=0xyour_deployed_contract_address

frontend/app/.env (for Expo): EXPO_PUBLIC_CONTRACT_ADDRESS=0xyour_deployed_contract_address

Copy these from .env.example and fill in real values. NEVER commit your PRIVATE_KEY to version control.

20. FILE STRUCTURE REFERENCE

f:\PLAYGROUND\project\
├── contracts\
│   └── SupplyChain.sol          ← The smart contract (core business logic)
├── scripts\
│   └── deploy.js                ← Deployment + demo data seeding script
├── test\
│   └── SupplyChain.js           ← All Hardhat/Chai test cases
├── frontend\app\
│   ├── App.js                   ← Full React Native consumer app
│   ├── app.json                 ← Expo config (app name, version, icons)
│   ├── index.js                 ← Expo entry point (registers App component)
│   └── package.json             ← Expo + ethers.js + chart-kit deps
├── dashboard\
│   ├── src\pages\
│   │   ├── index.js             ← The full Next.js admin dashboard page
│   │   ├── _app.js              ← Next.js app wrapper
│   │   └── _document.js        ← Next.js document wrapper
│   ├── next.config.js           ← Next.js configuration
│   ├── tailwind.config.js       ← Tailwind CSS configuration
│   └── package.json             ← Next.js + Recharts + ethers.js deps
├── web-app\
│   └── index.html               ← Standalone demo web page (no build needed)
├── artifacts\                   ← Compiled contract ABIs (auto-generated)
├── hardhat.config.js            ← Hardhat network & compiler configuration
├── package.json                 ← Root Hardhat dependencies
├── .env.example                 ← Template for environment variables
├── .gitignore                   ← Excludes node_modules, .env, etc.
├── README.md                    ← Project overview and quick-start guide
├── PITCH_DECK.md                ← Hackathon pitch slides in Markdown
├── OVERVIEW.txt                 ← THIS FILE (detailed project explanation)
└── instructions_for_running.txt ← Quick terminal commands to start everything

                  ## END OF CHAINFAIR OVERVIEW
                ### Author: github.com/spike-commander/
   ### Built with ❤️ for Jabalpur farmers and transparent supply chains
     ### Hackathonomics 2026 | Blockchain + Economics + Education

Clone this wiki locally