ESG DeFi Investing: Sustainable Yield Farming Strategies That Don't Burn the Planet

// Energy consumption comparison (annual TWh)
const blockchainEnergy = {
  bitcoin: 150,        // Still proof-of-work
  ethereumOld: 112,    // Pre-merge PoW
  ethereumNew: 0.01,   // Post-merge PoS
  polygon: 0.001,      // Proof-of-stake
  solana: 0.002        // Proof-of-history + PoS
};

console.log(`Ethereum energy reduction: ${
  ((blockchainEnergy.ethereumOld - blockchainEnergy.ethereumNew) / 
   blockchainEnergy.ethereumOld * 100).toFixed(1)
}% decrease`);
// Output: Ethereum energy reduction: 99.9% decrease

def calculate_environmental_score(protocol_data):
    """Calculate environmental ESG score for DeFi protocol"""
    
    # Blockchain efficiency (1-4 points)
    blockchain_scores = {
        'ethereum': 4,    # Post-merge PoS
        'polygon': 4,     # PoS with carbon-negative pledges
        'solana': 3,      # Energy-efficient but centralized
        'avalanche': 3,   # Subnet architecture
        'bitcoin': 1      # PoW energy intensive
    }
    
    # Carbon offset initiatives (1-3 points)
    carbon_offset = protocol_data.get('carbon_neutral_pledge', 0)
    offset_score = 3 if carbon_offset else 0
    
    # Renewable energy usage (1-3 points)
    renewable_energy = protocol_data.get('renewable_energy_percent', 0)
    renewable_score = min(3, renewable_energy / 33)  # 3 points at 100%
    
    blockchain = protocol_data.get('blockchain', '').lower()
    blockchain_score = blockchain_scores.get(blockchain, 1)
    
    total_score = blockchain_score + offset_score + renewable_score
    return min(10, total_score)

# Example usage
protocol_example = {
    'blockchain': 'polygon',
    'carbon_neutral_pledge': True,
    'renewable_energy_percent': 75
}

env_score = calculate_environmental_score(protocol_example)
print(f"Environmental Score: {env_score}/10")
# Output: Environmental Score: 9/10

// Smart contract example: Social impact tracking
pragma solidity ^0.8.19;

contract ESGSocialTracker {
    struct SocialMetrics {
        uint256 financialInclusionScore;  // 0-100
        uint256 communityParticipation;   // Active governance voters
        uint256 accessibilityFeatures;   // UI/UX accessibility points
        bool fairLaunch;                  // No pre-mine or VC allocation
    }
    
    mapping(address => SocialMetrics) public protocolMetrics;
    
    function calculateSocialScore(address protocol) 
        public 
        view 
        returns (uint256) 
    {
        SocialMetrics memory metrics = protocolMetrics[protocol];
        
        uint256 score = 0;
        score += metrics.financialInclusionScore / 10;  // Max 10 points
        score += (metrics.communityParticipation > 1000) ? 3 : 1;  // Community size
        score += metrics.accessibilityFeatures;  // Max 5 points
        score += metrics.fairLaunch ? 2 : 0;     // Fair launch bonus
        
        return score;  // Max 20 points, normalize to 10
    }
}

// Interacting with Aave on Polygon for sustainable yields
const { ethers } = require('ethers');

class SustainableAaveStrategy {
    constructor(provider, walletPrivateKey) {
        this.provider = provider;
        this.wallet = new ethers.Wallet(walletPrivateKey, provider);
        
        // Aave V3 Polygon addresses
        this.aavePool = '0x794a61358D6845594F94dc1DB02A252b5b4814aD';
        this.wmaticAddress = '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270';
    }
    
    async depositForYield(amount) {
        const aaveContract = new ethers.Contract(
            this.aavePool,
            ['function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode)'],
            this.wallet
        );
        
        try {
            // Supply WMATIC to earn yields
            const tx = await aaveContract.supply(
                this.wmaticAddress,
                ethers.parseEther(amount.toString()),
                this.wallet.address,
                0
            );
            
            console.log(`Sustainable yield farming initiated: ${tx.hash}`);
            return tx;
        } catch (error) {
            console.error('Deposit failed:', error);
        }
    }
    
    async getESGMetrics() {
        return {
            carbonFootprint: 'Minimal (Polygon PoS)',
            energyEfficiency: '99.9% reduction vs PoW',
            governanceParticipation: '15,000+ voters',
            socialImpact: 'Financial inclusion focused'
        };
    }
}

// Usage example
const strategy = new SustainableAaveStrategy(provider, privateKey);
await strategy.depositForYield(100); // Deposit 100 MATIC

import asyncio
from web3 import Web3

class ESGLiquidityStrategy:
    def __init__(self, web3_provider, private_key):
        self.w3 = Web3(web3_provider)
        self.account = self.w3.eth.account.from_key(private_key)
        
        # Focus on ESG-compliant token pairs
        self.sustainable_pairs = {
            'WETH/USDC': {
                'pool_address': '0x45dda9cb7c25131df268515131f647d726f50608',
                'esg_score': 8.5,
                'reason': 'Low energy consumption, high liquidity'
            },
            'MATIC/USDC': {
                'pool_address': '0xa374094527e1673a86de625aa59517c5de346d32',
                'esg_score': 9.0,
                'reason': 'Native sustainable blockchain token'
            }
        }
    
    def calculate_sustainable_apy(self, pair_name, fee_tier=0.3):
        """Calculate APY adjusted for ESG factors"""
        base_apy = self.get_base_apy(pair_name)  # From pool data
        pair_info = self.sustainable_pairs.get(pair_name, {})
        esg_score = pair_info.get('esg_score', 5)
        
        # ESG bonus: higher scores get preference
        esg_multiplier = 1 + (esg_score - 5) / 10  # 1.0 to 1.5x
        sustainable_apy = base_apy * esg_multiplier
        
        return {
            'base_apy': base_apy,
            'esg_adjusted_apy': sustainable_apy,
            'esg_score': esg_score,
            'sustainability_bonus': (esg_multiplier - 1) * 100
        }
    
    def get_base_apy(self, pair_name):
        # Placeholder - would fetch real pool data
        return 12.5  # Example 12.5% base APY

# Example usage
strategy = ESGLiquidityStrategy(web3_provider, private_key)
result = strategy.calculate_sustainable_apy('MATIC/USDC')
print(f"Sustainable APY: {result['esg_adjusted_apy']:.2f}%")
print(f"ESG Bonus: +{result['sustainability_bonus']:.1f}%")

// Curve stablecoin strategy for sustainable yields
class CurveESGStrategy {
    constructor(web3Provider, privateKey) {
        this.web3 = web3Provider;
        this.account = this.web3.eth.accounts.privateKeyToAccount(privateKey);
        
        // Focus on stablecoin pools (lower risk, steady yields)
        this.esgPools = {
            '3Pool': {
                address: '0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7',
                tokens: ['DAI', 'USDC', 'USDT'],
                avgAPY: 8.5,
                riskLevel: 'Low'
            }
        };
    }
    
    async calculateCarbonFootprint(poolName) {
        // Post-merge Ethereum carbon footprint
        const txPerDay = 100; // Estimated daily transactions
        const ethCarbonPerTx = 0.0001; // kg CO2 per transaction
        const dailyCarbon = txPerDay * ethCarbonPerTx;
        
        return {
            dailyCarbonKg: dailyCarbon,
            annualCarbonKg: dailyCarbon * 365,
            comparison: 'Lower than traditional banking operations'
        };
    }
    
    async getPoolESGRating(poolName) {
        const pool = this.esgPools[poolName];
        if (!pool) return null;
        
        return {
            environmental: 8, // Post-merge Ethereum
            social: 7,        // Stablecoin accessibility
            governance: 8,    // Curve DAO voting
            overall: 7.7,
            recommendation: pool.riskLevel === 'Low' ? 'Suitable for ESG portfolios' : 'Review needed'
        };
    }
}

def optimize_esg_portfolio(available_capital, risk_tolerance='moderate'):
    """Optimize DeFi portfolio for ESG compliance and returns"""
    
    protocols = {
        'aave_polygon': {'esg_score': 8.5, 'apy': 12.0, 'risk': 'low'},
        'uniswap_v3': {'esg_score': 8.0, 'apy': 15.5, 'risk': 'medium'},
        'curve_3pool': {'esg_score': 7.5, 'apy': 8.5, 'risk': 'low'},
        'compound_v3': {'esg_score': 7.8, 'apy': 10.2, 'risk': 'low'},
        'balancer_v2': {'esg_score': 7.2, 'apy': 14.8, 'risk': 'medium'}
    }
    
    # ESG-weighted allocation
    allocations = {}
    total_esg_weight = sum(p['esg_score'] for p in protocols.values())
    
    for protocol, data in protocols.items():
        # Weight by ESG score and adjust for risk tolerance
        base_weight = data['esg_score'] / total_esg_weight
        
        # Risk adjustment
        if risk_tolerance == 'conservative' and data['risk'] == 'medium':
            base_weight *= 0.5  # Reduce allocation to medium risk
        elif risk_tolerance == 'aggressive' and data['risk'] == 'low':
            base_weight *= 0.8  # Slightly reduce conservative allocations
        
        allocations[protocol] = {
            'percentage': base_weight * 100,
            'amount': available_capital * base_weight,
            'expected_annual_return': data['apy'] * base_weight / 100,
            'esg_score': data['esg_score']
        }
    
    return allocations

# Example portfolio optimization
portfolio = optimize_esg_portfolio(10000, 'moderate')
for protocol, allocation in portfolio.items():
    print(f"{protocol}: ${allocation['amount']:.0f} ({allocation['percentage']:.1f}%) - "
          f"ESG: {allocation['esg_score']}/10")

// Smart contract for ESG-based portfolio rebalancing
pragma solidity ^0.8.19;

contract ESGPortfolioRebalancer {
    struct ProtocolAllocation {
        address protocolAddress;
        uint256 targetPercentage;    // Basis points (100 = 1%)
        uint256 esgScore;           // 0-1000 (1000 = 10.0)
        uint256 currentBalance;
        bool isActive;
    }
    
    mapping(bytes32 => ProtocolAllocation) public allocations;
    bytes32[] public protocolIds;
    
    uint256 public constant REBALANCE_THRESHOLD = 500; // 5% deviation
    uint256 public constant MIN_ESG_SCORE = 700;       // Minimum 7.0 ESG score
    
    event Rebalanced(bytes32 indexed protocolId, uint256 oldBalance, uint256 newBalance);
    
    function addProtocol(
        bytes32 protocolId,
        address protocolAddress,
        uint256 targetPercentage,
        uint256 esgScore
    ) external {
        require(esgScore >= MIN_ESG_SCORE, "ESG score too low");
        require(targetPercentage <= 10000, "Invalid percentage");
        
        allocations[protocolId] = ProtocolAllocation({
            protocolAddress: protocolAddress,
            targetPercentage: targetPercentage,
            esgScore: esgScore,
            currentBalance: 0,
            isActive: true
        });
        
        protocolIds.push(protocolId);
    }
    
    function checkRebalanceNeeded() external view returns (bool) {
        uint256 totalValue = getTotalPortfolioValue();
        
        for (uint i = 0; i < protocolIds.length; i++) {
            ProtocolAllocation memory allocation = allocations[protocolIds[i]];
            if (!allocation.isActive) continue;
            
            uint256 currentPercentage = (allocation.currentBalance * 10000) / totalValue;
            uint256 deviation = currentPercentage > allocation.targetPercentage 
                ? currentPercentage - allocation.targetPercentage
                : allocation.targetPercentage - currentPercentage;
            
            if (deviation > REBALANCE_THRESHOLD) {
                return true;
            }
        }
        
        return false;
    }
    
    function getTotalPortfolioValue() public view returns (uint256) {
        // Implementation would calculate total value across all protocols
        return 0; // Placeholder
    }
}

class ESGPerformanceTracker {
    constructor(protocols) {
        this.protocols = protocols;
        this.startDate = new Date();
        this.performanceHistory = [];
    }
    
    async generateESGReport(timeframe = '30d') {
        const report = {
            timeframe,
            generatedAt: new Date(),
            performance: {},
            esgMetrics: {},
            carbonImpact: {},
            recommendations: []
        };
        
        // Calculate performance metrics
        for (const [name, protocol] of Object.entries(this.protocols)) {
            const performance = await this.calculateProtocolPerformance(protocol);
            report.performance[name] = performance;
            
            // ESG scoring over time
            const currentESG = await this.getESGScore(protocol);
            report.esgMetrics[name] = currentESG;
            
            // Carbon impact calculation
            const carbonData = await this.calculateCarbonImpact(protocol);
            report.carbonImpact[name] = carbonData;
        }
        
        // Generate recommendations
        report.recommendations = this.generateRecommendations(report);
        
        return report;
    }
    
    async calculateProtocolPerformance(protocol) {
        // Would integrate with DeFi protocol APIs
        return {
            totalReturn: 0.125,      // 12.5% return
            annualizedAPY: 0.148,    // 14.8% APY
            volatility: 0.032,       // 3.2% volatility
            sharpeRatio: 4.6,        // Risk-adjusted return
            maxDrawdown: -0.058      // -5.8% max drawdown
        };
    }
    
    async getESGScore(protocol) {
        // Integration with ESG data providers
        return {
            environmental: 8.2,
            social: 7.8,
            governance: 8.5,
            overall: 8.17,
            trend: 'improving'
        };
    }
    
    async calculateCarbonImpact(protocol) {
        const txCount = await this.getTransactionCount(protocol);
        const carbonPerTx = 0.0001; // kg CO2 per transaction (post-merge)
        
        return {
            totalTransactions: txCount,
            carbonFootprintKg: txCount * carbonPerTx,
            carbonOffset: txCount * carbonPerTx * 1.2, // 120% offset
            netCarbonImpact: -(txCount * carbonPerTx * 0.2) // Net negative
        };
    }
    
    generateRecommendations(report) {
        const recommendations = [];
        
        // Check for low ESG scores
        for (const [protocol, metrics] of Object.entries(report.esgMetrics)) {
            if (metrics.overall < 7.0) {
                recommendations.push({
                    type: 'esg_warning',
                    protocol,
                    message: `Consider reducing allocation to ${protocol} (ESG score: ${metrics.overall})`,
                    priority: 'high'
                });
            }
        }
        
        // Check for carbon impact
        const totalCarbon = Object.values(report.carbonImpact)
            .reduce((sum, impact) => sum + impact.carbonFootprintKg, 0);
        
        if (totalCarbon > 10) { // More than 10kg CO2 annually
            recommendations.push({
                type: 'carbon_reduction',
                message: 'Consider carbon offset programs or migration to more efficient protocols',
                priority: 'medium'
            });
        }
        
        return recommendations;
    }
    
    async getTransactionCount(protocol) {
        // Placeholder - would query blockchain
        return Math.floor(Math.random() * 1000) + 100;
    }
}

// Usage example
const tracker = new ESGPerformanceTracker({
    aave: { address: '0x...', chain: 'polygon' },
    uniswap: { address: '0x...', chain: 'polygon' }
});

const report = await tracker.generateESGReport('30d');
console.log('ESG Performance Report:', JSON.stringify(report, null, 2));

def assess_protocol_risks(protocol_address, chain='ethereum'):
    """Comprehensive risk assessment for DeFi protocols"""
    
    risk_factors = {
        'smart_contract': {
            'audit_count': 0,
            'audit_firms': [],
            'last_audit_date': None,
            'bug_bounty_program': False,
            'formal_verification': False
        },
        'governance': {
            'decentralization_score': 0,  # 0-10
            'voting_participation': 0,    # Percentage
            'timelock_duration': 0,       # Hours
            'multisig_threshold': 0       # N of M signatures
        },
        'liquidity': {
            'total_value_locked': 0,
            'liquidity_depth': 0,
            'daily_volume': 0,
            'impermanent_loss_risk': 'low'  # low, medium, high
        }
    }
    
    # Calculate overall risk score
    def calculate_risk_score(factors):
        score = 0
        
        # Smart contract security (40% weight)
        sc_score = min(10, factors['smart_contract']['audit_count'] * 2)
        sc_score += 2 if factors['smart_contract']['bug_bounty_program'] else 0
        sc_score += 2 if factors['smart_contract']['formal_verification'] else 0
        score += (sc_score / 14) * 40
        
        # Governance (30% weight)
        gov_score = factors['governance']['decentralization_score']
        gov_score += min(5, factors['governance']['voting_participation'] / 20)
        gov_score += min(3, factors['governance']['timelock_duration'] / 24)
        score += (gov_score / 18) * 30
        
        # Liquidity (30% weight)
        liq_score = min(10, factors['liquidity']['total_value_locked'] / 100_000_000)
        if factors['liquidity']['impermanent_loss_risk'] == 'low':
            liq_score += 5
        elif factors['liquidity']['impermanent_loss_risk'] == 'medium':
            liq_score += 2
        score += (liq_score / 15) * 30
        
        return min(100, score)
    
    risk_score = calculate_risk_score(risk_factors)
    
    return {
        'risk_score': risk_score,
        'risk_level': 'low' if risk_score > 70 else 'medium' if risk_score > 40 else 'high',
        'factors': risk_factors,
        'recommendation': 'Suitable for ESG portfolio' if risk_score > 70 else 'Requires additional due diligence'
    }

# Example usage
risk_assessment = assess_protocol_risks('0x7d2768de32b0b80b7a3454c06bdac94a69ddc7a9')  # Aave
print(f"Risk Score: {risk_assessment['risk_score']}/100")
print(f"Risk Level: {risk_assessment['risk_level']}")

// Example: Polygon's carbon-negative pledge tracking
class CarbonNegativeStrategy {
    constructor() {
        this.carbonCredits = new Map();
        this.protocolCommitments = {
            'polygon': {
                commitment: 'carbon_negative',
                offsetMultiplier: 1.1,  // 110% offset
                creditType: 'nature_based_solutions'
            },
            'celo': {
                commitment: 'carbon_negative',
                offsetMultiplier: 1.2,  // 120% offset
                creditType: 'reforestation'
            }
        };
    }
    
    calculateCarbonImpact(protocol, transactionCount) {
        const baseCarbon = transactionCount * 0.0001; // kg CO2
        const commitment = this.protocolCommitments[protocol];
        
        if (!commitment) {
            return { netImpact: baseCarbon, offsetCredits: 0 };
        }
        
        const offsetCredits = baseCarbon * commitment.offsetMultiplier;
        const netImpact = baseCarbon - offsetCredits;
        
        return {
            grossEmissions: baseCarbon,
            offsetCredits: offsetCredits,
            netImpact: netImpact, // Negative = carbon negative
            commitment: commitment.commitment,
            creditType: commitment.creditType
        };
    }
    
    async selectOptimalProtocol(protocols, targetYield = 0.10) {
        const results = [];
        
        for (const protocol of protocols) {
            const yieldData = await this.getProtocolYield(protocol);
            const carbonData = this.calculateCarbonImpact(protocol.name, 1000);
            
            // ESG-adjusted yield calculation
            const carbonBonus = carbonData.netImpact < 0 ? 0.01 : 0; // 1% bonus for carbon negative
            const adjustedYield = yieldData.baseYield + carbonBonus;
            
            results.push({
                protocol: protocol.name,
                baseYield: yieldData.baseYield,
                adjustedYield: adjustedYield,
                carbonImpact: carbonData,
                meetsTarget: adjustedYield >= targetYield
            });
        }
        
        return results.sort((a, b) => b.adjustedYield - a.adjustedYield);
    }
    
    async getProtocolYield(protocol) {
        // Placeholder - would fetch real yield data
        return {
            baseYield: Math.random() * 0.15 + 0.05, // 5-20% yield
            volatility: Math.random() * 0.1,
            updated: new Date()
        };
    }
}

// Smart contract for social impact tracking
pragma solidity ^0.8.19;

contract SocialImpactTracker {
    struct ImpactMetrics {
        uint256 uniqueUsers;
        uint256 developingCountryUsers;
        uint256 microTransactions;      // Transactions under $10
        uint256 financialEducationEvents;
        bool accessibilityCompliant;
        uint256 communityGrants;        // USD value
    }
    
    mapping(address => ImpactMetrics) public protocolImpacts;
    
    function calculateSocialScore(address protocol) 
        external 
        view 
        returns (uint256) 
    {
        ImpactMetrics memory impact = protocolImpacts[protocol];
        uint256 score = 0;
        
        // User diversity (0-25 points)
        if (impact.uniqueUsers > 100000) score += 15;
        else if (impact.uniqueUsers > 10000) score += 10;
        else if (impact.uniqueUsers > 1000) score += 5;
        
        if (impact.developingCountryUsers * 100 / impact.uniqueUsers > 50) {
            score += 10; // Bonus for global inclusion
        }
        
        // Micro-transaction support (0-20 points)
        uint256 microTxRatio = impact.microTransactions * 100 / 
            (impact.microTransactions + 1); // Avoid division by zero
        score += microTxRatio / 5; // Up to 20 points
        
        // Education and accessibility (0-30 points)
        score += impact.financialEducationEvents > 10 ? 15 : 
                impact.financialEducationEvents * 15 / 10;
        
        if (impact.accessibilityCompliant) score += 15;
        
        // Community support (0-25 points)
        if (impact.communityGrants > 1000000) score += 25; // $1M+
        else if (impact.communityGrants > 100000) score += 15; // $100K+
        else if (impact.communityGrants > 10000) score += 10; // $10K+
        
        return score; // Max 100 points
    }
}

import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime, timedelta

class ESGDeFiDashboard:
    def __init__(self):
        self.portfolios = {}
        self.esg_benchmarks = {
            'environmental': 7.0,
            'social': 6.5,
            'governance': 8.0
        }
    
    def add_position(self, protocol_name, amount, esg_scores):
        self.portfolios[protocol_name] = {
            'amount': amount,
            'esg_scores': esg_scores,
            'entry_date': datetime.now(),
            'performance_history': []
        }
    
    def generate_esg_report(self):
        """Generate comprehensive ESG performance report"""
        
        report_data = []
        total_value = sum(p['amount'] for p in self.portfolios.values())
        
        for protocol, data in self.portfolios.items():
            weight = data['amount'] / total_value
            esg = data['esg_scores']
            
            report_data.append({
                'Protocol': protocol,
                'Weight': f"{weight:.1%}",
                'Amount': f"${data['amount']:,.0f}",
                'Environmental': esg['environmental'],
                'Social': esg['social'],
                'Governance': esg['governance'],
                'Overall ESG': sum(esg.values()) / len(esg),
                'vs Benchmark': 'Above' if sum(esg.values()) / len(esg) > 7.0 else 'Below'
            })
        
        df = pd.DataFrame(report_data)
        
        # Calculate portfolio-weighted ESG scores
        weighted_esg = {}
        for metric in ['environmental', 'social', 'governance']:
            weighted_score = sum(
                self.portfolios[protocol]['esg_scores'][metric] * 
                (self.portfolios[protocol]['amount'] / total_value)
                for protocol in self.portfolios
            )
            weighted_esg[metric] = weighted_score
        
        print("=== ESG DeFi Portfolio Report ===")
        print(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        print(f"Total Portfolio Value: ${total_value:,.0f}")
        print("\nPortfolio-Weighted ESG Scores:")
        for metric, score in weighted_esg.items():
            benchmark = self.esg_benchmarks[metric]
            status = "✅" if score >= benchmark else "⚠️"
            print(f"{metric.title()}: {score:.1f}/10 {status} (Benchmark: {benchmark})")
        
        print(f"\nOverall ESG Score: {sum(weighted_esg.values()) / len(weighted_esg):.1f}/10")
        print("\n" + "="*50)
        print(df.to_string(index=False))
        
        return df, weighted_esg
    
    def plot_esg_performance(self):
        """Create ESG performance visualization"""
        protocols = list(self.portfolios.keys())
        esg_scores = [sum(self.portfolios[p]['esg_scores'].values()) / 3 
                     for p in protocols]
        amounts = [self.portfolios[p]['amount'] for p in protocols]
        
        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
        
        # ESG Score vs Allocation
        colors = ['green' if score >= 7.0 else 'orange' if score >= 5.0 else 'red' 
                 for score in esg_scores]
        
        ax1.scatter(esg_scores, amounts, c=colors, s=100, alpha=0.7)
        ax1.axvline(x=7.0, color='green', linestyle='--', alpha=0.5, label='ESG Benchmark')
        ax1.set_xlabel('ESG Score')
        ax1.set_ylabel('Allocation ($)')
        ax1.set_title('ESG Score vs Portfolio Allocation')
        ax1.legend()
        
        for i, protocol in enumerate(protocols):
            ax1.annotate(protocol, (esg_scores[i], amounts[i]), 
                        xytext=(5, 5), textcoords='offset points', fontsize=8)
        
        # ESG Category Breakdown
        categories = ['Environmental', 'Social', 'Governance']
        avg_scores = []
        
        for category in ['environmental', 'social', 'governance']:
            total_weight = sum(self.portfolios[p]['amount'] for p in protocols)
            weighted_avg = sum(
                self.portfolios[p]['esg_scores'][category] * 
                (self.portfolios[p]['amount'] / total_weight)
                for p in protocols
            )
            avg_scores.append(weighted_avg)
        
        bars = ax2.bar(categories, avg_scores, color=['green', 'blue', 'purple'], alpha=0.7)
        ax2.axhline(y=7.0, color='red', linestyle='--', alpha=0.5, label='Target: 7.0')
        ax2.set_ylabel('Weighted Average Score')
        ax2.set_title('Portfolio ESG Category Breakdown')
        ax2.set_ylim(0, 10)
        ax2.legend()
        
        # Add score labels on bars
        for bar, score in zip(bars, avg_scores):
            ax2.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.1,
                    f'{score:.1f}', ha='center', va='bottom')
        
        plt.tight_layout()
        plt.show()
        
        return fig

# Example usage
dashboard = ESGDeFiDashboard()

# Add some example positions
dashboard.add_position('Aave (Polygon)', 5000, {
    'environmental': 8.5, 'social': 7.5, 'governance': 8.0
})
dashboard.add_position('Uniswap V3', 3000, {
    'environmental': 8.0, 'social': 8.0, 'governance': 7.5
})
dashboard.add_position('Curve Finance', 2000, {
    'environmental': 7.5, 'social': 7.0, 'governance': 8.5
})

# Generate report and visualization
df, weighted_esg = dashboard.generate_esg_report()
dashboard.plot_esg_performance()

// Setup script for ESG DeFi investing
const ethers = require('ethers');

class ESGWalletSetup {
    async initialize() {
        console.log("🌱 Setting up your ESG DeFi wallet...");
        
        // Connect to sustainable networks first
        const networks = {
            polygon: {
                name: 'Polygon Mainnet',
                rpc: 'https://polygon-rpc.com/',
                chainId: 137,
                esgRating: 9, // High efficiency PoS
                nativeCurrency: 'MATIC'
            },
            ethereum: {
                name: 'Ethereum Mainnet',
                rpc: 'https://eth-mainnet.alchemyapi.io/v2/your-key',
                chainId: 1,
                esgRating: 8, // Post-merge PoS
                nativeCurrency: 'ETH'
            }
        };
        
        // Prioritize sustainable networks
        const sustainableNetworks = Object.entries(networks)
            .filter(([_, network]) => network.esgRating >= 8)
            .sort((a, b) => b[1].esgRating - a[1].esgRating);
        
        console.log("✅ Sustainable networks available:");
        sustainableNetworks.forEach(([name, network]) => {
            console.log(`   ${name}: ESG Rating ${network.esgRating}/10`);
        });
        
        return sustainableNetworks;
    }
    
    async checkWalletESGReadiness(walletAddress) {
        // Check if wallet has interacted with sustainable protocols
        const sustainableProtocols = [
            '0x8dff5e27ea6b7ac08ebfdf9eb090f32ee9a30fcf', // Aave Polygon
            '0x1f98431c8ad98523631ae4a59f267346ea31f984', // Uniswap V3
            '0x445fe580ef8d70ff569ab36e80c647af338db351'  // Curve
        ];
        
        // This would check on-chain interactions
        const esgScore = Math.floor(Math.random() * 5) + 6; // Placeholder
        
        return {
            address: walletAddress,
            esgInteractions: sustainableProtocols.length,
            esgReadinessScore: esgScore,
            recommendation: esgScore >= 7 
                ? "Ready for ESG DeFi investing" 
                : "Consider starting with conservative ESG protocols"
        };
    }
}

// Initialize your ESG DeFi journey
const setup = new ESGWalletSetup();
setup.initialize().then(networks => {
    console.log("\n🚀 Ready to start sustainable yield farming!");
    console.log("Recommended first step: Start with Aave on Polygon for low-risk ESG yields");
});

def create_starter_esg_portfolio(budget=1000):
    """Create a beginner-friendly ESG DeFi portfolio"""
    
    # Conservative ESG allocation for beginners
    allocations = {
        'aave_polygon_usdc': {
            'percentage': 40,
            'amount': budget * 0.4,
            'risk': 'Low',
            'esg_score': 8.5,
            'expected_apy': 8.5,
            'description': 'Stable lending on efficient Polygon network'
        },
        'curve_3pool': {
            'percentage': 30,
            'amount': budget * 0.3,
            'risk': 'Low',
            'esg_score': 7.5,
            'expected_apy': 6.8,
            'description': 'Stablecoin pool with minimal impermanent loss'
        },
        'uniswap_v3_eth_usdc': {
            'percentage': 20,
            'amount': budget * 0.2,
            'risk': 'Medium',
            'esg_score': 8.0,
            'expected_apy': 12.0,
            'description': 'Blue-chip liquidity provision'
        },
        'emergency_reserve': {
            'percentage': 10,
            'amount': budget * 0.1,
            'risk': 'None',
            'esg_score': 10,
            'expected_apy': 0,
            'description': 'Cash reserve for opportunities'
        }
    }
    
    # Calculate portfolio metrics
    weighted_esg = sum(
        alloc['esg_score'] * (alloc['percentage'] / 100)
        for alloc in allocations.values()
        if alloc['esg_score'] > 0
    )
    
    weighted_apy = sum(
        alloc['expected_apy'] * (alloc['percentage'] / 100)
        for alloc in allocations.values()
    )
    
    print("🌱 Your ESG DeFi Starter Portfolio")
    print("=" * 40)
    print(f"Total Budget: ${budget:,.0f}")
    print(f"Portfolio ESG Score: {weighted_esg:.1f}/10")
    print(f"Expected Portfolio APY: {weighted_apy:.1f}%")
    print("\nAllocations:")
    
    for name, alloc in allocations.items():
        print(f"  {name.replace('_', ' ').title()}:")
        print(f"    Amount: ${alloc['amount']:,.0f} ({alloc['percentage']}%)")
        print(f"    ESG Score: {alloc['esg_score']}/10")
        print(f"    Expected APY: {alloc['expected_apy']}%")
        print(f"    Risk Level: {alloc['risk']}")
        print()
    
    # Investment timeline
    print("📅 Recommended Timeline:")
    print("Week 1: Start with Aave USDC (lowest risk)")
    print("Week 2: Add Curve 3Pool position")
    print("Week 3: Consider Uniswap V3 if comfortable")
    print("Month 2+: Monitor and rebalance monthly")
    
    return allocations

# Create your starter portfolio
portfolio = create_starter_esg_portfolio(1000)