GreenCoin Platform Documentation

// Carbon sequestration calculation example
function calculateCarbonSequestration(farmData) {
  const {
    soilCarbonChange,     // tons C/ha/year
    biomassGrowth,        // tons C/ha/year
    practiceEfficiency,   // 0.0 - 1.0
    leakageDiscount,      // 0.0 - 0.2
    buffer               // 0.1 - 0.3 (risk buffer)
  } = farmData;
  
  // Total carbon sequestration
  const totalSequestration = (soilCarbonChange + biomassGrowth) * practiceEfficiency;
  
  // Apply leakage discount
  const adjustedSequestration = totalSequestration * (1 - leakageDiscount);
  
  // Apply conservative buffer
  const finalSequestration = adjustedSequestration * (1 - buffer);
  
  // Convert to CO2 equivalent (multiply by 44/12)
  const co2Equivalent = finalSequestration * 3.67;
  
  return {
    totalSequestration,
    co2Equivalent,
    creditsGenerated: Math.floor(co2Equivalent * 100) / 100 // Round to 2 decimals
  };
}
        

// backend/src/services/mrvService.ts
import { PrismaClient, Project, Farm } from '@prisma/client';
import axios from 'axios';

const prisma = new PrismaClient();

interface CarbonCalculationInput {
  farmId: number;
  projectId: number;
  startDate: Date;
  endDate: Date;
  methodology: 'field-sampling' | 'modeling' | 'hybrid';
  practices: string[];
}

interface CarbonCalculationResult {
  totalCO2Sequestered: number;
  totalCO2Avoided: number;
  netCO2Impact: number;
  creditsEligible: number;
  confidenceScore: number;
  breakdown: {
    soilCarbon: number;
    biomassCarbon: number;
    emissionReductions: number;
    buffer: number;
  };
  practiceContributions: Array<{
    practice: string;
    area: number;
    co2Contribution: number;
    confidence: number;
  }>;
}

class MRVService {
  
  /**
   * Calculate carbon sequestration for a farm project
   */
  async calculateCarbonSequestration(
    input: CarbonCalculationInput
  ): Promise {
    
    // Fetch farm and project data
    const farm = await prisma.farm.findUnique({
      where: { id: input.farmId },
      include: { user: true, activities: true }
    });
    
    const project = await prisma.project.findUnique({
      where: { id: input.projectId },
      include: { verifications: true }
    });
    
    if (!farm || !project) {
      throw new Error('Farm or Project not found');
    }
    
    // Calculate based on methodology
    let result: CarbonCalculationResult;
    
    switch (input.methodology) {
      case 'field-sampling':
        result = await this.calculateFromFieldData(farm, project, input);
        break;
      case 'modeling':
        result = await this.calculateFromModeling(farm, project, input);
        break;
      case 'hybrid':
        result = await this.calculateHybridApproach(farm, project, input);
        break;
      default:
        throw new Error('Invalid methodology');
    }
    
    // Store calculation in database
    await this.storeCarbonCalculation(input.projectId, result);
    
    return result;
  }
  
  /**
   * Field-based carbon calculation using soil samples
   */
  private async calculateFromFieldData(
    farm: any,
    project: any,
    input: CarbonCalculationInput
  ): Promise {
    
    // Fetch soil sampling data
    const soilSamples = await prisma.farmActivity.findMany({
      where: {
        farmId: farm.id,
        activityType: 'soil_sampling',
        date: {
          gte: input.startDate,
          lte: input.endDate
        }
      }
    });
    
    if (soilSamples.length === 0) {
      throw new Error('No soil sampling data available');
    }
    
    // Calculate soil organic carbon change
    const socChange = this.calculateSOCChange(soilSamples, farm.size);
    
    // Calculate biomass carbon
    const biomassCarbon = this.calculateBiomassCarbon(farm, input.practices);
    
    // Calculate emission reductions
    const emissionReductions = this.calculateEmissionReductions(
      input.practices,
      farm.size
    );
    
    // Apply IPCC Tier 2 methodology
    const totalSequestration = socChange + biomassCarbon;
    const totalAvoided = emissionReductions;
    
    // Apply conservative buffers (20% for uncertainty)
    const buffer = totalSequestration * 0.20;
    const creditsEligible = (totalSequestration - buffer) + totalAvoided;
    
    // Convert to CO2 equivalent (C to CO2 = multiply by 44/12)
    const co2Equivalent = creditsEligible * 3.67;
    
    return {
      totalCO2Sequestered: totalSequestration * 3.67,
      totalCO2Avoided: totalAvoided * 3.67,
      netCO2Impact: (totalSequestration + totalAvoided) * 3.67,
      creditsEligible: co2Equivalent,
      confidenceScore: 0.92, // High confidence with field data
      breakdown: {
        soilCarbon: socChange * 3.67,
        biomassCarbon: biomassCarbon * 3.67,
        emissionReductions: totalAvoided * 3.67,
        buffer: buffer * 3.67
      },
      practiceContributions: await this.calculatePracticeContributions(
        input.practices,
        farm.size
      )
    };
  }
  
  /**
   * Model-based calculation using satellite data
   */
  private async calculateFromModeling(
    farm: any,
    project: any,
    input: CarbonCalculationInput
  ): Promise {
    
    // Get satellite NDVI data
    const ndviData = await this.fetchSatelliteNDVI(
      farm.location,
      input.startDate,
      input.endDate
    );
    
    // Apply COMET-Farm model
    const cometResults = await this.runCOMETModel({
      location: farm.location,
      size: farm.size,
      practices: input.practices,
      climateData: await this.fetchClimateData(farm.location),
      ndvi: ndviData
    });
    
    // Apply 30% uncertainty buffer for modeling
    const buffer = cometResults.totalSequestration * 0.30;
    const creditsEligible = (cometResults.totalSequestration - buffer);
    
    return {
      totalCO2Sequestered: cometResults.totalSequestration,
      totalCO2Avoided: cometResults.emissionReductions,
      netCO2Impact: cometResults.totalSequestration + cometResults.emissionReductions,
      creditsEligible: creditsEligible * 3.67,
      confidenceScore: 0.75, // Lower confidence with modeling
      breakdown: {
        soilCarbon: cometResults.soilCarbon,
        biomassCarbon: cometResults.biomassCarbon,
        emissionReductions: cometResults.emissionReductions,
        buffer: buffer * 3.67
      },
      practiceContributions: cometResults.practiceBreakdown
    };
  }
  
  /**
   * Hybrid approach combining field data and modeling
   */
  private async calculateHybridApproach(
    farm: any,
    project: any,
    input: CarbonCalculationInput
  ): Promise {
    
    // Get both field and model results
    const fieldResult = await this.calculateFromFieldData(farm, project, input);
    const modelResult = await this.calculateFromModeling(farm, project, input);
    
    // Weighted average (70% field data, 30% modeling)
    const totalSequestration = 
      (fieldResult.totalCO2Sequestered * 0.7) + 
      (modelResult.totalCO2Sequestered * 0.3);
    
    const totalAvoided = 
      (fieldResult.totalCO2Avoided * 0.7) + 
      (modelResult.totalCO2Avoided * 0.3);
    
    // Apply 15% buffer for hybrid approach
    const buffer = totalSequestration * 0.15;
    
    return {
      totalCO2Sequestered: totalSequestration,
      totalCO2Avoided: totalAvoided,
      netCO2Impact: totalSequestration + totalAvoided,
      creditsEligible: (totalSequestration - buffer) + totalAvoided,
      confidenceScore: 0.85, // Good confidence with hybrid
      breakdown: {
        soilCarbon: (fieldResult.breakdown.soilCarbon * 0.7) + 
                    (modelResult.breakdown.soilCarbon * 0.3),
        biomassCarbon: (fieldResult.breakdown.biomassCarbon * 0.7) + 
                       (modelResult.breakdown.biomassCarbon * 0.3),
        emissionReductions: totalAvoided,
        buffer: buffer
      },
      practiceContributions: this.mergePracticeContributions(
        fieldResult.practiceContributions,
        modelResult.practiceContributions
      )
    };
  }
  
  /**
   * Calculate Soil Organic Carbon (SOC) change
   */
  private calculateSOCChange(soilSamples: any[], farmSize: number): number {
    // IPCC Tier 2 methodology
    const avgSOC = soilSamples.reduce((sum, sample) => {
      return sum + (sample.metadata?.organicCarbon || 0);
    }, 0) / soilSamples.length;
    
    // Baseline SOC (assume 2% for degraded soil)
    const baselineSOC = 2.0;
    
    // SOC change per hectare (tons C/ha/year)
    const socChangePerHa = (avgSOC - baselineSOC) / 100 * 1.5; // 1.5 tons/ha soil mass
    
    return socChangePerHa * farmSize;
  }
  
  /**
   * Calculate biomass carbon sequestration
   */
  private calculateBiomassCarbon(farm: any, practices: string[]): number {
    let biomassCarbonPerHa = 0;
    
    // Agroforestry contribution
    if (practices.includes('agroforestry')) {
      biomassCarbonPerHa += 5.0; // 5 tons C/ha/year
    }
    
    // Cover cropping contribution
    if (practices.includes('cover-cropping')) {
      biomassCarbonPerHa += 1.2; // 1.2 tons C/ha/year
    }
    
    // No-till residue retention
    if (practices.includes('no-till')) {
      biomassCarbonPerHa += 0.8; // 0.8 tons C/ha/year
    }
    
    return biomassCarbonPerHa * farm.size;
  }
  
  /**
   * Calculate emission reductions from practices
   */
  private calculateEmissionReductions(
    practices: string[],
    farmSize: number
  ): number {
    let reductionsPerHa = 0;
    
    // Reduced tillage - lower fuel use
    if (practices.includes('no-till') || practices.includes('reduced-tillage')) {
      reductionsPerHa += 0.3; // 0.3 tons CO2/ha/year
    }
    
    // Improved fertilizer management
    if (practices.includes('precision-fertilization')) {
      reductionsPerHa += 0.5; // 0.5 tons CO2/ha/year (N2O reduction)
    }
    
    // Efficient irrigation
    if (practices.includes('drip-irrigation')) {
      reductionsPerHa += 0.2; // 0.2 tons CO2/ha/year (energy savings)
    }
    
    return reductionsPerHa * farmSize;
  }
  
  /**
   * Fetch satellite NDVI data from Sentinel-2
   */
  private async fetchSatelliteNDVI(
    location: string,
    startDate: Date,
    endDate: Date
  ): Promise {
    
    const [lat, lng] = location.split(',').map(Number);
    
    try {
      // Example: Sentinel Hub API integration
      const response = await axios.post(
        'https://services.sentinel-hub.com/api/v1/process',
        {
          input: {
            bounds: {
              bbox: [lng - 0.01, lat - 0.01, lng + 0.01, lat + 0.01]
            },
            data: [{
              type: 'sentinel-2-l2a',
              dataFilter: {
                timeRange: {
                  from: startDate.toISOString(),
                  to: endDate.toISOString()
                }
              }
            }]
          },
          evalscript: `
            //VERSION=3
            function setup() {
              return {
                input: ["B04", "B08"],
                output: { bands: 1 }
              };
            }
            function evaluatePixel(sample) {
              let ndvi = (sample.B08 - sample.B04) / (sample.B08 + sample.B04);
              return [ndvi];
            }
          `
        },
        {
          headers: {
            'Authorization': `Bearer ${process.env.SENTINEL_API_KEY}`,
            'Content-Type': 'application/json'
          }
        }
      );
      
      return response.data.ndvi || [];
    } catch (error) {
      console.error('Satellite data fetch error:', error);
      return [0.6]; // Default NDVI for agricultural land
    }
  }
  
  /**
   * Run COMET-Farm carbon model
   */
  private async runCOMETModel(params: any): Promise {
    // COMET-Farm model implementation
    // This is a simplified version - actual implementation would call COMET API
    
    const baselineEmissions = 5.0; // tons CO2/ha/year
    let sequestration = 0;
    
    // Calculate based on practices
    params.practices.forEach((practice: string) => {
      switch (practice) {
        case 'no-till':
          sequestration += 0.8 * params.size;
          break;
        case 'cover-cropping':
          sequestration += 1.2 * params.size;
          break;
        case 'agroforestry':
          sequestration += 6.0 * params.size;
          break;
        case 'composting':
          sequestration += 0.9 * params.size;
          break;
      }
    });
    
    return {
      totalSequestration: sequestration,
      soilCarbon: sequestration * 0.6,
      biomassCarbon: sequestration * 0.4,
      emissionReductions: baselineEmissions * 0.3 * params.size,
      practiceBreakdown: params.practices.map((p: string) => ({
        practice: p,
        area: params.size,
        co2Contribution: sequestration / params.practices.length,
        confidence: 0.75
      }))
    };
  }
  
  /**
   * Store carbon calculation results
   */
  private async storeCarbonCalculation(
    projectId: number,
    result: CarbonCalculationResult
  ): Promise {
    
    await prisma.credit.create({
      data: {
        projectId: projectId,
        userId: (await prisma.project.findUnique({ 
          where: { id: projectId } 
        }))!.userId,
        amount: result.creditsEligible,
        status: 'pending',
        // Store detailed results in metadata JSON field
      }
    });
  }
  
  /**
   * Calculate practice-level contributions
   */
  private async calculatePracticeContributions(
    practices: string[],
    farmSize: number
  ): Promise> {
    
    const contributions = practices.map(practice => {
      let co2PerHa = 0;
      let confidence = 0.85;
      
      switch (practice) {
        case 'no-till':
          co2PerHa = 0.8 * 3.67;
          confidence = 0.90;
          break;
        case 'cover-cropping':
          co2PerHa = 1.2 * 3.67;
          confidence = 0.85;
          break;
        case 'agroforestry':
          co2PerHa = 6.0 * 3.67;
          confidence = 0.80;
          break;
        case 'composting':
          co2PerHa = 0.9 * 3.67;
          confidence = 0.88;
          break;
        default:
          co2PerHa = 0.5 * 3.67;
      }
      
      return {
        practice,
        area: farmSize,
        co2Contribution: co2PerHa * farmSize,
        confidence
      };
    });
    
    return contributions;
  }
  
  /**
   * Merge practice contributions from multiple methods
   */
  private mergePracticeContributions(
    fieldContributions: any[],
    modelContributions: any[]
  ): any[] {
    
    return fieldContributions.map((fc, index) => ({
      practice: fc.practice,
      area: fc.area,
      co2Contribution: (fc.co2Contribution * 0.7) + 
                       (modelContributions[index]?.co2Contribution || 0) * 0.3,
      confidence: (fc.confidence * 0.7) + 
                  (modelContributions[index]?.confidence || 0.7) * 0.3
    }));
  }
}

export const mrvService = new MRVService();
        

// backend/src/controllers/mrvController.ts
import { Request, Response } from 'express';
import { mrvService } from '../services/mrvService';
import { z } from 'zod';

// Validation schema
const carbonCalculationSchema = z.object({
  farmId: z.number().int().positive(),
  projectId: z.number().int().positive(),
  startDate: z.string().datetime(),
  endDate: z.string().datetime(),
  methodology: z.enum(['field-sampling', 'modeling', 'hybrid']),
  practices: z.array(z.string()).min(1)
});

/**
 * POST /api/mrv/calculate
 * Calculate carbon sequestration for a farm project
 */
export const calculateCarbon = async (req: Request, res: Response) => {
  try {
    // Validate request body
    const validation = carbonCalculationSchema.safeParse(req.body);
    
    if (!validation.success) {
      return res.status(400).json({
        success: false,
        error: 'Validation failed',
        details: validation.error.errors
      });
    }
    
    const input = {
      ...validation.data,
      startDate: new Date(validation.data.startDate),
      endDate: new Date(validation.data.endDate)
    };
    
    // Calculate carbon sequestration
    const result = await mrvService.calculateCarbonSequestration(input);
    
    res.status(200).json({
      success: true,
      data: result,
      timestamp: new Date().toISOString()
    });
    
  } catch (error: any) {
    console.error('MRV calculation error:', error);
    res.status(500).json({
      success: false,
      error: error.message || 'Failed to calculate carbon sequestration'
    });
  }
};

/**
 * GET /api/mrv/report/:projectId
 * Generate MRV report for a project
 */
export const generateReport = async (req: Request, res: Response) => {
  try {
    const projectId = parseInt(req.params.projectId);
    
    // Fetch project with all related data
    const project = await prisma.project.findUnique({
      where: { id: projectId },
      include: {
        user: true,
        credits: true,
        verifications: true,
        documents: true
      }
    });
    
    if (!project) {
      return res.status(404).json({
        success: false,
        error: 'Project not found'
      });
    }
    
    // Generate comprehensive MRV report
    const report = {
      projectInfo: {
        id: project.id,
        name: project.name,
        description: project.description,
        status: project.status,
        methodology: project.methodology,
        confidenceScore: project.confidenceScore
      },
      farmer: {
        name: `${project.user.firstName} ${project.user.lastName}`,
        email: project.user.email
      },
      carbonCredits: {
        total: project.credits.reduce((sum, c) => sum + c.amount, 0),
        pending: project.credits.filter(c => c.status === 'pending').length,
        earned: project.credits.filter(c => c.status === 'earned').length,
        retired: project.credits.filter(c => c.status === 'retired').length
      },
      verificationStatus: {
        current: project.verificationStatus,
        progress: project.verificationProgress,
        timeline: project.verifications.map(v => ({
          type: v.type,
          status: v.status,
          timestamp: v.timestamp,
          description: v.description
        }))
      },
      documents: project.documents.map(d => ({
        filename: d.filename,
        uploadedAt: d.uploadedAt
      })),
      generatedAt: new Date().toISOString()
    };
    
    res.status(200).json({
      success: true,
      data: report
    });
    
  } catch (error: any) {
    console.error('Report generation error:', error);
    res.status(500).json({
      success: false,
      error: error.message || 'Failed to generate report'
    });
  }
};
        

// backend/src/routes/mrv.ts
import { Router } from 'express';
import { auth } from '../middleware/auth';
import { calculateCarbon, generateReport } from '../controllers/mrvController';

const router = Router();

// All routes require authentication
router.use(auth);

/**
 * POST /api/mrv/calculate
 * Calculate carbon sequestration for a farm project
 */
router.post('/calculate', calculateCarbon);

/**
 * GET /api/mrv/report/:projectId
 * Generate comprehensive MRV report
 */
router.get('/report/:projectId', generateReport);

/**
 * GET /api/mrv/satellite/:farmId
 * Fetch satellite data for farm monitoring
 */
router.get('/satellite/:farmId', async (req, res) => {
  // Implementation for satellite data retrieval
  res.json({ success: true, data: 'Satellite data endpoint' });
});

export default router;
        

// backend/src/index.ts (add to existing routes)
import mrvRouter from './routes/mrv';

// ... existing code ...

// Add MRV routes
app.use('/api/mrv', mrvRouter);
        

// Frontend: Calculate carbon sequestration
const calculateCarbonCredits = async (projectData) => {
  const response = await fetch('http://localhost:3000/api/mrv/calculate', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({
      farmId: 1,
      projectId: 5,
      startDate: '2024-01-01T00:00:00Z',
      endDate: '2024-12-31T23:59:59Z',
      methodology: 'hybrid',
      practices: [
        'no-till',
        'cover-cropping',
        'agroforestry',
        'composting'
      ]
    })
  });
  
  const result = await response.json();
  
  if (result.success) {
    console.log('Carbon Credits Eligible:', result.data.creditsEligible);
    console.log('Confidence Score:', result.data.confidenceScore);
    console.log('Breakdown:', result.data.breakdown);
  }
};

// Generate MRV report
const getMRVReport = async (projectId) => {
  const response = await fetch(
    `http://localhost:3000/api/mrv/report/${projectId}`,
    {
      headers: {
        'Authorization': `Bearer ${token}`
      }
    }
  );
  
  const report = await response.json();
  return report.data;
};
        

# Add to backend/.env
SENTINEL_API_KEY=your_sentinel_hub_api_key
LANDSAT_API_KEY=your_landsat_api_key
PLANET_LABS_API_KEY=your_planet_labs_api_key
WEATHER_API_KEY=your_weather_api_key

# External API endpoints
SENTINEL_API_URL=https://services.sentinel-hub.com/api/v1
COMET_FARM_API_URL=https://comet-farm-api.example.com
WEATHER_API_URL=https://api.openweathermap.org/data/2.5
        

// Farmer registration record
interface Farmer {
  id: Text;                    // Unique farmer identifier
  name: Text;                  // Full legal name
  location: Text;              // GPS coordinates (lat,lng)
  farmSize: Float;             // Area in hectares
  practices: [Text];           // Array of adopted practices
  registrationDate: Text;      // ISO 8601 timestamp
  verificationStatus: Text;    // "pending" | "verified" | "rejected"
  contactInfo: ContactInfo;
  landTenure: LandTenureInfo;
  baseline: BaselineData;
}

// Contact information
interface ContactInfo {
  phoneNumber: Text;
  email: ?Text;                // Optional email
  physicalAddress: Text;
  preferredLanguage: Text;     // "en" | "sw" | "fr" | etc.
  emergencyContact: Text;
}

// Land tenure documentation
interface LandTenureInfo {
  ownershipType: Text;         // "owned" | "leased" | "communal"
  documentNumber: Text;        // Title deed or lease agreement number
  expiryDate: ?Text;          // For leased land
  legalVerification: Bool;     // Document verification status
}

// Baseline carbon measurements
interface BaselineData {
  soilOrganicCarbon: Float;    // Percentage or tons/ha
  biomassCarbon: Float;        // tons C/ha
  measurementDate: Text;
  samplingPoints: [GPSPoint];
  labResults: [LabResult];
}

// Carbon estimate record
interface CarbonEstimate {
  id: Text;
  farmerId: Text;
  period: Text;                // "YYYY-MM-DD to YYYY-MM-DD"
  methodology: Text;           // "field-sampling" | "modeling" | "hybrid"
  co2eSequestered: Float;      // tons CO2 equivalent
  co2eAvoided: Float;          // tons CO2 equivalent from avoided emissions
  practicesImplemented: [Practice];
  confidence: Float;           // 0.0 - 1.0 confidence score
  verificationStatus: Text;
  timestamp: Text;
  calculationDetails: CalculationBreakdown;
}

// Practice implementation details
interface Practice {
  type: Text;                  // "cover-cropping" | "no-till" | etc.
  area: Float;                 // hectares covered
  implementationDate: Text;
  effectiveness: Float;        // 0.0 - 1.0 implementation quality
  evidence: [Evidence];        // Photos, GPS tracks, etc.
}

// Evidence documentation
interface Evidence {
  type: Text;                  // "photo" | "gps-track" | "receipt" | etc.
  url: Text;                   // IPFS hash or cloud storage URL
  timestamp: Text;
  gpsLocation: ?Text;
  description: Text;
}

// Credit transaction record
interface CreditTransaction {
  txId: Text;                  // Blockchain transaction ID
  farmerId: Text;
  amount: Float;               // Number of credits
  pricePerCredit: Float;       // USD per credit
  totalValue: Float;           // Total payment in USD
  walletAddress: Text;         // ICP wallet address
  status: Text;                // "pending" | "completed" | "failed"
  issuanceDate: Text;
  vintageYear: Nat;            // Year of carbon sequestration
  methodology: Text;
  serialNumbers: [Text];       // VCS registry serial numbers
}

// Marketplace listing
interface CreditListing {
  listingId: Text;
  sellerId: Text;              // Farmer or aggregator ID
  credits: [CreditBatch];
  pricePerCredit: Float;
  totalCredits: Float;
  description: Text;
  cobenefits: [Text];          // Additional sustainability benefits
  location: Text;              // Geographic origin
  certifications: [Text];      // VCS, Gold Standard, etc.
  listedDate: Text;
  status: Text;                // "active" | "sold" | "expired"
}

// Credit batch information
interface CreditBatch {
  batchId: Text;
  vintageYear: Nat;
  methodology: Text;
  quantity: Float;
  verificationBody: Text;
  projectId: Text;
  additionalityProof: Text;
}
        

// API Response wrapper
type ApiResponse = {
  success: Bool;
  data: ?T;
  error: ?ApiError;
  timestamp: Text;
  requestId: Text;
}

// Error types
type ApiError = {
  code: Text;                  // "FARMER_NOT_FOUND" | "INVALID_GPS" | etc.
  message: Text;
  details: ?Text;
  retryable: Bool;
}

// Validation result
type ValidationResult = {
  isValid: Bool;
  errors: [ValidationError];
  warnings: [ValidationWarning];
}

type ValidationError = {
  field: Text;
  code: Text;
  message: Text;
}
        

# Clone repository
git clone https://github.com/DrewGalowayDev/Greencoin-Edition.git
cd Greencoin-Edition/backend

# Install dependencies
npm install

# Create environment file
cp .env.example .env

# Edit .env with your credentials
DATABASE_URL="mysql://user:password@localhost:3306/greencoin"
JWT_SECRET="your-super-secret-jwt-key"
SMTP_HOST="smtp.gmail.com"
SMTP_PORT=587
SMTP_USER="your-email@gmail.com"
SMTP_PASS="your-app-password"
FRONTEND_URL="http://localhost:5173"
PORT=3000

# Generate Prisma Client
npm run prisma:generate

# Run database migrations
npm run migrate

# Start development server
npm run dev
        

# Navigate to admin dashboard
cd ../Admin-Dashboard

# Install dependencies
npm install

# Start development server (port 5173)
npm run dev

# Build for production
npm run build

# Preview production build
npm run preview
        

# Navigate to farmers dashboard
cd ../Farmers-Dashboard

# Install dependencies
npm install

# Start development server (port 8080)
npm run dev

# Build for production
npm run build

# For mobile: Sync with Capacitor
npm run cap:sync
npm run android:dev  # Open Android Studio
        

# Navigate to landing page
cd ../green-landing\ page

# Install dependencies
npm install

# Start development server (port 5175)
npm run dev

# Build Android APK
npm run android:build
        

# Create new migration
cd backend
npx prisma migrate dev --name your_migration_name

# View database in Prisma Studio
npm run studio

# Reset database (WARNING: deletes all data)
npx prisma migrate reset

# Deploy migrations to production
npm run prisma:migrate
        

# Backend deployment (e.g., DigitalOcean, AWS, Heroku)
# 1. Set environment variables on hosting platform
# 2. Build TypeScript
npm run build

# 3. Start production server
npm start

# Frontend deployment (e.g., Vercel, Netlify)
# Admin Dashboard
cd Admin-Dashboard
npm run build
# Upload dist/ folder to hosting

# Farmers Dashboard  
cd Farmers-Dashboard
npm run build
# Upload dist/ folder to hosting

# Database (recommended: PlanetScale, AWS RDS)
# 1. Create production MySQL instance
# 2. Update DATABASE_URL in production
# 3. Run migrations
npx prisma migrate deploy