Renewable Energy Trading Platform

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

contract EnergyTrading {
    struct EnergyOffer {
        address producer;
        uint256 energyAmount; // in kWh
        uint256 pricePerKWh;  // in wei
        uint256 timestamp;
        bool isActive;
    }
    
    struct EnergyDemand {
        address consumer;
        uint256 energyNeeded;
        uint256 maxPricePerKWh;
        uint256 timestamp;
        bool isFulfilled;
    }
    
    mapping(uint256 => EnergyOffer) public offers;
    mapping(uint256 => EnergyDemand) public demands;
    mapping(address => uint256) public energyBalances;
    
    event EnergyTraded(
        address indexed producer,
        address indexed consumer,
        uint256 energyAmount,
        uint256 totalPrice
    );
    
    function createOffer(
        uint256 _energyAmount,
        uint256 _pricePerKWh
    ) external returns (uint256) {
        require(_energyAmount > 0, "Energy amount must be positive");
        require(_pricePerKWh > 0, "Price must be positive");
        
        uint256 offerId = uint256(keccak256(abi.encodePacked(
            msg.sender, _energyAmount, block.timestamp
        )));
        
        offers[offerId] = EnergyOffer({
            producer: msg.sender,
            energyAmount: _energyAmount,
            pricePerKWh: _pricePerKWh,
            timestamp: block.timestamp,
            isActive: true
        });
        
        return offerId;
    }
    
    function matchEnergyTrade(
        uint256 _offerId,
        uint256 _demandId
    ) external {
        EnergyOffer storage offer = offers[_offerId];
        EnergyDemand storage demand = demands[_demandId];
        
        require(offer.isActive, "Offer not active");
        require(!demand.isFulfilled, "Demand already fulfilled");
        require(offer.pricePerKWh <= demand.maxPricePerKWh, "Price mismatch");
        
        uint256 tradeAmount = min(offer.energyAmount, demand.energyNeeded);
        uint256 totalPrice = tradeAmount * offer.pricePerKWh;
        
        // Execute trade
        offer.energyAmount -= tradeAmount;
        demand.energyNeeded -= tradeAmount;
        
        if (offer.energyAmount == 0) offer.isActive = false;
        if (demand.energyNeeded == 0) demand.isFulfilled = true;
        
        // Transfer payment
        payable(offer.producer).transfer(totalPrice);
        
        emit EnergyTraded(offer.producer, demand.consumer, tradeAmount, totalPrice);
    }
}

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestRegressor
from sklearn.preprocessing import StandardScaler
import joblib

class EnergyDemandPredictor:
    def __init__(self):
        self.model = RandomForestRegressor(n_estimators=100, random_state=42)
        self.scaler = StandardScaler()
        self.feature_columns = [
            'hour', 'day_of_week', 'month', 'temperature', 
            'humidity', 'solar_irradiance', 'wind_speed',
            'historical_demand_1h', 'historical_demand_24h'
        ]
    
    def prepare_features(self, data):
        """Prepare features for model training/prediction"""
        features = pd.DataFrame()
        
        # Time-based features
        features['hour'] = data.index.hour
        features['day_of_week'] = data.index.dayofweek
        features['month'] = data.index.month
        
        # Weather features
        features['temperature'] = data['temperature']
        features['humidity'] = data['humidity']
        features['solar_irradiance'] = data['solar_irradiance']
        features['wind_speed'] = data['wind_speed']
        
        # Historical demand features
        features['historical_demand_1h'] = data['demand'].shift(1)
        features['historical_demand_24h'] = data['demand'].shift(24)
        
        return features.fillna(method='bfill')
    
    def train(self, historical_data):
        """Train the demand prediction model"""
        features = self.prepare_features(historical_data)
        target = historical_data['demand']
        
        # Remove rows with NaN values
        mask = ~(features.isnull().any(axis=1) | target.isnull())
        features_clean = features[mask]
        target_clean = target[mask]
        
        # Scale features
        features_scaled = self.scaler.fit_transform(features_clean)
        
        # Train model
        self.model.fit(features_scaled, target_clean)
        
        # Save model
        joblib.dump(self.model, 'energy_demand_model.pkl')
        joblib.dump(self.scaler, 'feature_scaler.pkl')
    
    def predict(self, current_data, hours_ahead=24):
        """Predict energy demand for next N hours"""
        predictions = []
        
        for h in range(hours_ahead):
            features = self.prepare_features(current_data)
            features_scaled = self.scaler.transform(features.iloc[-1:])
            
            prediction = self.model.predict(features_scaled)[0]
            predictions.append(prediction)
            
            # Update current_data with prediction for next iteration
            next_timestamp = current_data.index[-1] + pd.Timedelta(hours=1)
            current_data.loc[next_timestamp, 'demand'] = prediction
        
        return np.array(predictions)