How to Track Yield Farming Team Movements: Developer Migration Impact on Protocol Performance

// Monitor developer wallet deployments
async function trackDeveloperDeployments(developerAddress) {
  const apiKey = process.env.ETHERSCAN_API_KEY;
  const endpoint = `https://api.etherscan.io/api?module=account&action=txlist&address=${developerAddress}&sort=desc&apikey=${apiKey}`;
  
  try {
    const response = await fetch(endpoint);
    const data = await response.json();
    
    // Filter contract creation transactions
    const deployments = data.result.filter(tx => 
      tx.to === '' && tx.input !== '0x'
    );
    
    return deployments.map(tx => ({
      hash: tx.hash,
      timestamp: new Date(tx.timeStamp * 1000),
      contractAddress: tx.contractAddress,
      gasUsed: tx.gasUsed
    }));
  } catch (error) {
    console.error('Deployment tracking failed:', error);
    return [];
  }
}

// Usage example
const recentDeployments = await trackDeveloperDeployments('0x742d35Cc6634C0532925a3b8D');
console.log('New contracts:', recentDeployments);

# Track multisig signer changes using Web3.py
from web3 import Web3
import json

def monitor_multisig_changes(multisig_address, w3_provider):
    """Monitor multisig wallet signer modifications"""
    w3 = Web3(Web3.HTTPProvider(w3_provider))
    
    # Standard Gnosis Safe ABI fragment for owner changes
    owner_events = [
        'AddedOwner(address)',
        'RemovedOwner(address)', 
        'ChangedThreshold(uint256)'
    ]
    
    # Get recent events (last 1000 blocks)
    latest_block = w3.eth.block_number
    events = []
    
    for event_sig in owner_events:
        try:
            event_filter = w3.eth.filter({
                'address': multisig_address,
                'topics': [w3.keccak(text=event_sig).hex()],
                'fromBlock': latest_block - 1000,
                'toBlock': 'latest'
            })
            
            logs = event_filter.get_all_entries()
            events.extend(logs)
        except Exception as e:
            print(f"Event filtering error: {e}")
    
    return events

# Monitor Yearn Finance multisig (example)
changes = monitor_multisig_changes('0xfeb4acf3df3cdea7399794d0869ef76a6efaff52', 'your_rpc_endpoint')
print(f"Detected {len(changes)} multisig changes")

#!/bin/bash
# Track developer commit patterns across protocol repositories

analyze_dev_activity() {
    local repo_url=$1
    local developer_email=$2
    local days_back=${3:-30}
    
    # Clone repository temporarily
    temp_dir=$(mktemp -d)
    git clone "$repo_url" "$temp_dir" 2>/dev/null
    cd "$temp_dir" || exit
    
    # Analyze commit frequency by developer
    since_date=$(date -d "$days_back days ago" "+%Y-%m-%d")
    
    echo "=== Commit Analysis for $developer_email ==="
    echo "Repository: $repo_url"
    echo "Period: Last $days_back days"
    echo ""
    
    # Recent commits by developer
    recent_commits=$(git log --author="$developer_email" --since="$since_date" --oneline | wc -l)
    echo "Recent commits: $recent_commits"
    
    # Lines added/removed
    git log --author="$developer_email" --since="$since_date" --numstat | \
        awk '{added+=$1; removed+=$2} END {print "Lines added:", added, "Lines removed:", removed}'
    
    # Last commit date
    last_commit=$(git log --author="$developer_email" -1 --format="%cd" --date=short)
    echo "Last commit: $last_commit"
    
    # Cleanup
    rm -rf "$temp_dir"
}

# Monitor multiple protocol repositories
repos=(
    "https://github.com/yearn/yearn-protocol"
    "https://github.com/Uniswap/v3-core"
    "https://github.com/aave/protocol-v2"
)

for repo in "${repos[@]}"; do
    analyze_dev_activity "$repo" "developer@protocol.com" 14
    echo "----------------------------------------"
done

# Twitter monitoring for developer activity changes
import tweepy
import re
from datetime import datetime, timedelta

class DeveloperTwitterMonitor:
    def __init__(self, api_key, api_secret, access_token, token_secret):
        auth = tweepy.OAuthHandler(api_key, api_secret)
        auth.set_access_token(access_token, token_secret)
        self.api = tweepy.API(auth)
    
    def analyze_developer_tweets(self, username, days_back=7):
        """Analyze recent tweets for migration signals"""
        migration_keywords = [
            'new project', 'exciting announcement', 'big news coming',
            'new venture', 'starting fresh', 'new chapter'
        ]
        
        try:
            # Get recent tweets
            tweets = tweepy.Cursor(
                self.api.user_timeline, 
                screen_name=username,
                tweet_mode='extended',
                exclude_replies=True
            ).items(50)
            
            signals = []
            cutoff_date = datetime.now() - timedelta(days=days_back)
            
            for tweet in tweets:
                if tweet.created_at < cutoff_date:
                    continue
                    
                # Check for migration keywords
                text_lower = tweet.full_text.lower()
                found_keywords = [kw for kw in migration_keywords if kw in text_lower]
                
                if found_keywords:
                    signals.append({
                        'date': tweet.created_at,
                        'text': tweet.full_text,
                        'keywords': found_keywords,
                        'retweets': tweet.retweet_count,
                        'likes': tweet.favorite_count
                    })
            
            return signals
            
        except tweepy.TweepError as e:
            print(f"Twitter API error: {e}")
            return []

# Usage example
monitor = DeveloperTwitterMonitor(api_key, api_secret, access_token, token_secret)
signals = monitor.analyze_developer_tweets('protocol_dev_handle')
print(f"Found {len(signals)} potential migration signals")

# LinkedIn profile monitoring (using web scraping - respect rate limits)
import requests
from bs4 import BeautifulSoup
import time
import json
from datetime import datetime

class LinkedInProfileMonitor:
    def __init__(self):
        self.session = requests.Session()
        self.session.headers.update({
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
        })
    
    def check_profile_changes(self, profile_url, previous_data=None):
        """Monitor LinkedIn profile for changes"""
        try:
            response = self.session.get(profile_url)
            soup = BeautifulSoup(response.content, 'html.parser')
            
            # Extract current profile data
            current_data = {
                'job_title': self.extract_job_title(soup),
                'company': self.extract_company(soup),
                'location': self.extract_location(soup),
                'timestamp': datetime.now().isoformat()
            }
            
            # Compare with previous data
            if previous_data:
                changes = self.detect_changes(previous_data, current_data)
                return current_data, changes
            
            return current_data, []
            
        except Exception as e:
            print(f"Profile monitoring error: {e}")
            return None, []
    
    def extract_job_title(self, soup):
        """Extract current job title"""
        title_elem = soup.find('h1', class_='text-heading-xlarge')
        return title_elem.text.strip() if title_elem else None
    
    def extract_company(self, soup):
        """Extract current company"""
        company_elem = soup.find('div', class_='text-body-medium break-words')
        return company_elem.text.strip() if company_elem else None
    
    def detect_changes(self, old_data, new_data):
        """Detect significant profile changes"""
        changes = []
        
        # Check job title changes
        if old_data.get('job_title') != new_data.get('job_title'):
            changes.append({
                'type': 'job_title_change',
                'old': old_data.get('job_title'),
                'new': new_data.get('job_title'),
                'significance': 'high'
            })
        
        # Check company changes
        if old_data.get('company') != new_data.get('company'):
            changes.append({
                'type': 'company_change',
                'old': old_data.get('company'),
                'new': new_data.get('company'),
                'significance': 'critical'
            })
        
        return changes

# Monitor developer profiles
monitor = LinkedInProfileMonitor()
profiles_to_track = [
    'https://linkedin.com/in/protocol-developer-1',
    'https://linkedin.com/in/protocol-developer-2'
]

for profile_url in profiles_to_track:
    current_data, changes = monitor.check_profile_changes(profile_url)
    if changes:
        print(f"Profile changes detected for {profile_url}:")
        for change in changes:
            print(f"- {change['type']}: {change['old']} → {change['new']}")
    time.sleep(5)  # Rate limiting

// Yield farming team migration alert system
class TeamMigrationMonitor {
  constructor(config) {
    this.config = config;
    this.alerts = [];
    this.riskScore = 0;
  }

  async runFullAnalysis(protocolData) {
    const results = {
      onChainSignals: await this.analyzeOnChainActivity(protocolData),
      githubActivity: await this.analyzeGithubActivity(protocolData),
      socialSignals: await this.analyzeSocialSignals(protocolData),
      timestamp: new Date().toISOString()
    };

    // Calculate composite risk score
    this.riskScore = this.calculateRiskScore(results);
    
    // Generate alerts if risk threshold exceeded
    if (this.riskScore > this.config.alertThreshold) {
      await this.sendAlert(results);
    }

    return results;
  }

  calculateRiskScore(data) {
    let score = 0;
    
    // On-chain activity weights
    if (data.onChainSignals.newDeployments > 2) score += 30;
    if (data.onChainSignals.multisigChanges > 0) score += 40;
    if (data.onChainSignals.unusualTransactions > 5) score += 20;
    
    // GitHub activity weights
    if (data.githubActivity.commitDecrease > 0.5) score += 25;
    if (data.githubActivity.developerInactivity > 14) score += 35;
    
    // Social signal weights
    if (data.socialSignals.migrationKeywords > 3) score += 20;
    if (data.socialSignals.profileChanges > 1) score += 15;
    
    return Math.min(score, 100); // Cap at 100
  }

  async sendAlert(analysisResults) {
    const alert = {
      protocol: this.config.protocolName,
      riskScore: this.riskScore,
      severity: this.getRiskSeverity(this.riskScore),
      signals: this.extractKeySignals(analysisResults),
      timestamp: new Date().toISOString(),
      recommendations: this.generateRecommendations(this.riskScore)
    };

    // Send via multiple channels
    await Promise.all([
      this.sendEmailAlert(alert),
      this.sendDiscordAlert(alert),
      this.logToDatabase(alert)
    ]);
  }

  getRiskSeverity(score) {
    if (score >= 80) return 'CRITICAL';
    if (score >= 60) return 'HIGH'; 
    if (score >= 40) return 'MEDIUM';
    return 'LOW';
  }

  generateRecommendations(score) {
    const recommendations = [];
    
    if (score >= 80) {
      recommendations.push('Consider immediate position exit');
      recommendations.push('Monitor for official team announcements');
    } else if (score >= 60) {
      recommendations.push('Reduce position size by 50%');
      recommendations.push('Set tight stop-loss orders');
    } else if (score >= 40) {
      recommendations.push('Increase monitoring frequency');
      recommendations.push('Prepare exit strategy');
    }
    
    return recommendations;
  }
}

// Usage example
const monitor = new TeamMigrationMonitor({
  protocolName: 'YieldProtocol',
  alertThreshold: 60,
  emailRecipients: ['trader@example.com'],
  discordWebhook: 'your_webhook_url'
});

// Run analysis every 6 hours
setInterval(async () => {
  const protocolData = {
    contractAddresses: ['0x123...', '0x456...'],
    githubRepos: ['yearn/yearn-protocol'],
    teamMembers: ['dev1@protocol.com', 'dev2@protocol.com'],
    socialAccounts: ['@protocol_dev1', '@protocol_dev2']
  };
  
  const results = await monitor.runFullAnalysis(protocolData);
  console.log(`Analysis complete. Risk score: ${monitor.riskScore}`);
}, 6 * 60 * 60 * 1000);

# Team migration risk assessment framework
import numpy as np
from dataclasses import dataclass
from typing import List, Dict
from datetime import datetime, timedelta

@dataclass
class MigrationSignal:
    signal_type: str
    strength: float  # 0-1 scale
    confidence: float  # 0-1 scale
    timestamp: datetime
    description: str

class MigrationRiskAssessor:
    def __init__(self):
        # Signal type weights (based on historical accuracy)
        self.weights = {
            'contract_deployment': 0.35,
            'github_inactivity': 0.25, 
            'multisig_changes': 0.40,
            'social_indicators': 0.15,
            'funding_movements': 0.30
        }
        
        # Time decay factor (newer signals weighted higher)
        self.time_decay_days = 30
    
    def assess_migration_risk(self, signals: List[MigrationSignal]) -> Dict:
        """Calculate overall migration risk from multiple signals"""
        
        if not signals:
            return {'risk_score': 0, 'confidence': 0, 'key_signals': []}
        
        weighted_scores = []
        confidence_scores = []
        current_time = datetime.now()
        
        # Process each signal type
        signal_groups = self.group_signals_by_type(signals)
        
        for signal_type, type_signals in signal_groups.items():
            if signal_type not in self.weights:
                continue
                
            # Calculate average strength for this signal type
            type_strengths = []
            type_confidences = []
            
            for signal in type_signals:
                # Apply time decay
                days_old = (current_time - signal.timestamp).days
                time_factor = max(0, 1 - (days_old / self.time_decay_days))
                
                adjusted_strength = signal.strength * time_factor
                type_strengths.append(adjusted_strength)
                type_confidences.append(signal.confidence)
            
            if type_strengths:
                avg_strength = np.mean(type_strengths)
                avg_confidence = np.mean(type_confidences)
                
                # Weight by signal type importance
                weighted_score = avg_strength * self.weights[signal_type]
                weighted_scores.append(weighted_score)
                confidence_scores.append(avg_confidence)
        
        # Calculate final risk score
        overall_risk = np.sum(weighted_scores)
        overall_confidence = np.mean(confidence_scores) if confidence_scores else 0
        
        # Identify key contributing signals
        key_signals = self.identify_key_signals(signals, threshold=0.7)
        
        return {
            'risk_score': min(overall_risk, 1.0),
            'confidence': overall_confidence,
            'key_signals': key_signals,
            'signal_breakdown': self.create_breakdown(signal_groups),
            'assessment_time': current_time.isoformat()
        }
    
    def group_signals_by_type(self, signals: List[MigrationSignal]) -> Dict:
        """Group signals by type for analysis"""
        groups = {}
        for signal in signals:
            if signal.signal_type not in groups:
                groups[signal.signal_type] = []
            groups[signal.signal_type].append(signal)
        return groups
    
    def identify_key_signals(self, signals: List[MigrationSignal], threshold: float) -> List[Dict]:
        """Identify the most significant signals above threshold"""
        key_signals = []
        
        for signal in signals:
            if signal.strength >= threshold:
                key_signals.append({
                    'type': signal.signal_type,
                    'strength': signal.strength,
                    'confidence': signal.confidence,
                    'description': signal.description,
                    'age_hours': (datetime.now() - signal.timestamp).total_seconds() / 3600
                })
        
        # Sort by strength descending
        return sorted(key_signals, key=lambda x: x['strength'], reverse=True)

# Example usage
assessor = MigrationRiskAssessor()

# Sample signals from monitoring systems
signals = [
    MigrationSignal(
        signal_type='contract_deployment',
        strength=0.8,
        confidence=0.9,
        timestamp=datetime.now() - timedelta(days=2),
        description='Core developer deployed new contracts with similar functionality'
    ),
    MigrationSignal(
        signal_type='github_inactivity', 
        strength=0.6,
        confidence=0.7,
        timestamp=datetime.now() - timedelta(days=5),
        description='50% decrease in commit activity over past 2 weeks'
    ),
    MigrationSignal(
        signal_type='social_indicators',
        strength=0.7,
        confidence=0.6,
        timestamp=datetime.now() - timedelta(hours=12),
        description='Lead developer posted about "exciting new opportunities"'
    )
]

# Assess migration risk
risk_assessment = assessor.assess_migration_risk(signals)
print(f"Migration Risk Score: {risk_assessment['risk_score']:.2f}")
print(f"Confidence Level: {risk_assessment['confidence']:.2f}")
print(f"Key Signals: {len(risk_assessment['key_signals'])}")

# Dynamic position sizing based on migration risk
def calculate_position_size(portfolio_value, risk_score, base_allocation=0.1):
    """Calculate optimal position size based on migration risk"""
    
    # Risk adjustment factor (higher risk = smaller position)
    risk_adjustment = 1 - (risk_score * 0.7)  # Max 70% reduction
    
    # Apply minimum position threshold
    min_allocation = 0.02  # 2% minimum
    adjusted_allocation = max(base_allocation * risk_adjustment, min_allocation)
    
    return portfolio_value * adjusted_allocation

# Example portfolio allocation
portfolio_value = 100000  # $100k portfolio
protocols = [
    {'name': 'Protocol A', 'risk_score': 0.2},
    {'name': 'Protocol B', 'risk_score': 0.6}, 
    {'name': 'Protocol C', 'risk_score': 0.8}
]

for protocol in protocols:
    position_size = calculate_position_size(
        portfolio_value, 
        protocol['risk_score']
    )
    print(f"{protocol['name']}: ${position_size:,.0f} ({position_size/portfolio_value:.1%})")

// Automated exit strategy implementation
class MigrationExitStrategy {
  constructor(protocol, initialRiskScore) {
    this.protocol = protocol;
    this.initialRiskScore = initialRiskScore;
    this.exitTriggers = this.setExitTriggers(initialRiskScore);
    this.positionSize = this.calculateInitialPosition();
  }

  setExitTriggers(baseRiskScore) {
    return {
      // Gradual exit thresholds
      reduce25: baseRiskScore + 0.15,  // Reduce position 25%
      reduce50: baseRiskScore + 0.25,  // Reduce position 50%
      reduce75: baseRiskScore + 0.35,  // Reduce position 75%
      fullExit: baseRiskScore + 0.45   // Complete exit
    };
  }

  async evaluateExit(currentRiskScore, marketData) {
    const actions = [];
    
    // Check each exit threshold
    if (currentRiskScore >= this.exitTriggers.fullExit) {
      actions.push({
        action: 'FULL_EXIT',
        urgency: 'IMMEDIATE',
        percentage: 100,
        reason: 'Critical migration risk detected'
      });
    } else if (currentRiskScore >= this.exitTriggers.reduce75) {
      actions.push({
        action: 'REDUCE_POSITION',
        urgency: 'HIGH',
        percentage: 75,
        reason: 'High migration risk - major reduction'
      });
    } else if (currentRiskScore >= this.exitTriggers.reduce50) {
      actions.push({
        action: 'REDUCE_POSITION', 
        urgency: 'MEDIUM',
        percentage: 50,
        reason: 'Elevated migration risk detected'
      });
    } else if (currentRiskScore >= this.exitTriggers.reduce25) {
      actions.push({
        action: 'REDUCE_POSITION',
        urgency: 'LOW', 
        percentage: 25,
        reason: 'Early migration risk signals'
      });
    }

    // Execute actions if any triggers hit
    for (const action of actions) {
      await this.executeExit(action);
    }

    return actions;
  }

  async executeExit(action) {
    console.log(`Executing ${action.action} for ${this.protocol}`);
    console.log(`Percentage: ${action.percentage}%`);
    console.log(`Reason: ${action.reason}`);
    
    // Implementation would connect to DEX protocols
    // for actual token swaps and position closure
    
    // Update position tracking
    if (action.action === 'FULL_EXIT') {
      this.positionSize = 0;
    } else {
      this.positionSize *= (1 - action.percentage / 100);
    }
  }
}

// Monitor and execute exit strategies
const exitStrategy = new MigrationExitStrategy('YieldProtocol', 0.3);

// Simulate risk score increase triggering exits
const riskScores = [0.3, 0.45, 0.55, 0.65, 0.75];

for (const score of riskScores) {
  const actions = await exitStrategy.evaluateExit(score, {});
  if (actions.length > 0) {
    console.log(`Risk score ${score}: Executed ${actions.length} exit actions`);
  }
}

# NLP-based migration sentiment analysis
import nltk
from textblob import TextBlob
import re
from collections import Counter
import pandas as pd

class MigrationSentimentAnalyzer:
    def __init__(self):
        # Migration-related keyword categories
        self.migration_patterns = {
            'departure_signals': [
                'moving on', 'new chapter', 'exciting opportunity',
                'different direction', 'time to go', 'farewell'
            ],
            'dissatisfaction_signals': [
                'frustrating', 'disappointed', 'not aligned', 
                'different vision', 'toxic', 'burnout'
            ],
            'preparation_signals': [
                'transition', 'handover', 'stepping back',
                'reducing involvement', 'winding down'
            ]
        }
    
    def analyze_text_sentiment(self, text_data):
        """Analyze text for migration sentiment signals"""
        results = {
            'overall_sentiment': 0,
            'migration_probability': 0,
            'key_phrases': [],
            'signal_breakdown': {}
        }
        
        if not text_data:
            return results
        
        # Combine all text for analysis
        combined_text = ' '.join(text_data) if isinstance(text_data, list) else text_data
        combined_text = combined_text.lower()
        
        # Sentiment analysis using TextBlob
        blob = TextBlob(combined_text)
        results['overall_sentiment'] = blob.sentiment.polarity
        
        # Check for migration signal patterns
        total_signals = 0
        
        for category, patterns in self.migration_patterns.items():
            found_patterns = []
            for pattern in patterns:
                if pattern in combined_text:
                    found_patterns.append(pattern)
                    total_signals += 1
            
            results['signal_breakdown'][category] = {
                'count': len(found_patterns),
                'patterns': found_patterns
            }
        
        # Calculate migration probability
        # Negative sentiment + migration signals = higher probability
        sentiment_factor = max(0, -results['overall_sentiment'])  # Convert negative to positive
        signal_density = total_signals / max(len(combined_text.split()), 1) * 1000
        
        results['migration_probability'] = min(
            (sentiment_factor * 0.6 + signal_density * 0.4), 1.0
        )
        
        # Extract key phrases using frequency analysis
        words = re.findall(r'\b\w+\b', combined_text)
        word_freq = Counter(words)
        results['key_phrases'] = [word for word, count in word_freq.most_common(10)]
        
        return results
    
    def analyze_developer_communications(self, communication_data):
        """Analyze multiple communication channels for migration signals"""
        channel_results = {}
        
        for channel, messages in communication_data.items():
            if messages:
                channel_results[channel] = self.analyze_text_sentiment(messages)
        
        # Calculate weighted average across channels
        if channel_results:
            weights = {'twitter': 0.4, 'github': 0.3, 'discord': 0.2, 'blog': 0.1}
            
            weighted_probability = 0
            total_weight = 0
            
            for channel, result in channel_results.items():
                weight = weights.get(channel, 0.1)
                weighted_probability += result['migration_probability'] * weight
                total_weight += weight
            
            overall_probability = weighted_probability / total_weight if total_weight > 0 else 0
        else:
            overall_probability = 0
        
        return {
            'overall_migration_probability': overall_probability,
            'channel_analysis': channel_results,
            'recommendation': self.generate_recommendation(overall_probability)
        }
    
    def generate_recommendation(self, probability):
        """Generate actionable recommendations based on migration probability"""
        if probability >= 0.8:
            return "CRITICAL: Immediate position review recommended"
        elif probability >= 0.6:
            return "HIGH: Consider reducing exposure"
        elif probability >= 0.4:
            return "MEDIUM: Increase monitoring frequency"
        elif probability >= 0.2:
            return "LOW: Continue normal monitoring"
        else:
            return "MINIMAL: No immediate action required"

# Example usage
analyzer = MigrationSentimentAnalyzer()

# Sample developer communications
sample_communications = {
    'twitter': [
        "Feeling burnt out lately, need to focus on new opportunities",
        "The project direction doesn't align with my vision anymore",
        "Exciting things coming soon, can't share details yet"
    ],
    'github': [
        "This will be my last major commit for a while",
        "Transitioning responsibilities to other team members"
    ],
    'discord': [
        "I'll be stepping back from daily operations",
        "Time for a new chapter in my career"
    ]
}

# Analyze communications
results = analyzer.analyze_developer_communications(sample_communications)
print(f"Migration Probability: {results['overall_migration_probability']:.2f}")
print(f"Recommendation: {results['recommendation']}")

# Machine learning model for migration prediction
import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.preprocessing import StandardScaler

class MigrationPredictor:
    def __init__(self):
        self.model = RandomForestClassifier(n_estimators=100, random_state=42)
        self.scaler = StandardScaler()
        self.feature_names = [
            'github_commits_30d', 'github_commits_90d', 
            'multisig_changes', 'new_deployments',
            'social_sentiment', 'token_movements',
            'team_size_change', 'funding_status'
        ]
        
    def prepare_training_data(self):
        """Generate training data from historical migrations"""
        # Sample historical data (in practice, this would be real data)
        training_data = [
            # [features], migration_occurred (0/1)
            [15, 45, 2, 3, -0.3, 5, -1, 1, 1],  # Migration occurred
            [25, 80, 0, 1, 0.1, 2, 0, 1, 0],    # No migration
            [8, 20, 3, 5, -0.6, 8, -2, 0, 1],   # Migration occurred
            [30, 95, 1, 2, 0.3, 1, 1, 1, 0],    # No migration
            [5, 15, 4, 7, -0.8, 12, -3, 0, 1],  # Migration occurred
            [22, 70, 0, 2, 0.2, 3, 0, 1, 0],    # No migration
            [12, 35, 2, 4, -0.4, 6, -1, 1, 1],  # Migration occurred
            [28, 85, 1, 1, 0.4, 2, 1, 1, 0],    # No migration
        ]
        
        df = pd.DataFrame(training_data, 
                         columns=self.feature_names + ['migrated'])
        
        return df
    
    def train_model(self, training_data=None):
        """Train the migration prediction model"""
        if training_data is None:
            training_data = self.prepare_training_data()
        
        # Prepare features and labels
        X = training_data[self.feature_names]
        y = training_data['migrated']
        
        # Split data
        X_train, X_test, y_train, y_test = train_test_split(
            X, y, test_size=0.3, random_state=42
        )
        
        # Scale features
        X_train_scaled = self.scaler.fit_transform(X_train)
        X_test_scaled = self.scaler.transform(X_test)
        
        # Train model
        self.model.fit(X_train_scaled, y_train)
        
        # Evaluate model
        y_pred = self.model.predict(X_test_scaled)
        print("Model Performance:")
        print(classification_report(y_test, y_pred))
        
        # Feature importance
        importance_df = pd.DataFrame({
            'feature': self.feature_names,
            'importance': self.model.feature_importances_
        }).sort_values('importance', ascending=False)
        
        print("\nFeature Importance:")
        print(importance_df)
        
        return self.model
    
    def predict_migration_probability(self, protocol_data):
        """Predict migration probability for a protocol"""
        # Prepare feature vector
        features = np.array([protocol_data[feature] for feature in self.feature_names]).reshape(1, -1)
        
        # Scale features
        features_scaled = self.scaler.transform(features)
        
        # Get prediction probability
        probabilities = self.model.predict_proba(features_scaled)
        migration_probability = probabilities[0][1]  # Probability of migration
        
        # Get feature contributions
        feature_contributions = self.analyze_feature_contributions(protocol_data)
        
        return {
            'migration_probability': migration_probability,
            'risk_level': self.categorize_risk(migration_probability),
            'key_factors': feature_contributions,
            'recommendation': self.generate_ml_recommendation(migration_probability)
        }
    
    def analyze_feature_contributions(self, protocol_data):
        """Analyze which features contribute most to the prediction"""
        feature_values = [protocol_data[feature] for feature in self.feature_names]
        importances = self.model.feature_importances_
        
        contributions = []
        for i, (feature, value, importance) in enumerate(zip(self.feature_names, feature_values, importances)):
            contributions.append({
                'feature': feature,
                'value': value,
                'importance': importance,
                'risk_contribution': value * importance
            })
        
        # Sort by risk contribution
        contributions.sort(key=lambda x: abs(x['risk_contribution']), reverse=True)
        
        return contributions[:5]  # Top 5 contributing factors
    
    def categorize_risk(self, probability):
        """Categorize migration probability into risk levels"""
        if probability >= 0.8:
            return "CRITICAL"
        elif probability >= 0.6:
            return "HIGH"
        elif probability >= 0.4:
            return "MEDIUM"
        elif probability >= 0.2:
            return "LOW"
        else:
            return "MINIMAL"
    
    def generate_ml_recommendation(self, probability):
        """Generate ML-based recommendations"""
        recommendations = []
        
        if probability >= 0.7:
            recommendations.extend([
                "Consider immediate position exit or significant reduction",
                "Activate emergency monitoring protocols",
                "Prepare for potential liquidity issues"
            ])
        elif probability >= 0.5:
            recommendations.extend([
                "Reduce position size by 40-60%",
                "Set tight stop-loss orders",
                "Increase monitoring frequency to daily"
            ])
        elif probability >= 0.3:
            recommendations.extend([
                "Consider modest position reduction (20-30%)",
                "Monitor key developers more closely",
                "Review exit strategy preparation"
            ])
        else:
            recommendations.append("Continue standard monitoring procedures")
        
        return recommendations

# Example usage
predictor = MigrationPredictor()

# Train the model
predictor.train_model()

# Predict migration for a specific protocol
protocol_metrics = {
    'github_commits_30d': 10,    # Low recent activity
    'github_commits_90d': 25,    # Decreasing trend
    'multisig_changes': 2,       # Recent signer changes
    'new_deployments': 4,        # New contracts deployed
    'social_sentiment': -0.5,    # Negative sentiment
    'token_movements': 7,        # Unusual token transfers
    'team_size_change': -2,      # Team members left
    'funding_status': 0          # Funding issues
}

# Get prediction
prediction = predictor.predict_migration_probability(protocol_metrics)

print(f"Migration Probability: {prediction['migration_probability']:.2f}")
print(f"Risk Level: {prediction['risk_level']}")
print(f"Top Contributing Factors:")
for factor in prediction['key_factors']:
    print(f"  - {factor['feature']}: {factor['value']} (impact: {factor['risk_contribution']:.3f})")

// Automated portfolio rebalancing system
class DeFiPortfolioManager {
  constructor(initialCapital, riskTolerance = 0.5) {
    this.totalCapital = initialCapital;
    this.riskTolerance = riskTolerance;
    this.positions = new Map();
    this.migrationMonitor = new TeamMigrationMonitor();
    this.rebalanceThreshold = 0.1; // 10% allocation deviation triggers rebalance
  }

  async addProtocol(protocolName, targetAllocation, initialRisk) {
    this.positions.set(protocolName, {
      targetAllocation,
      currentAllocation: 0,
      currentValue: 0,
      migrationRisk: initialRisk,
      lastRiskUpdate: new Date(),
      performanceHistory: []
    });

    // Calculate initial position size
    await this.rebalancePortfolio();
  }

  async updateMigrationRisks() {
    for (const [protocolName, position] of this.positions) {
      try {
        // Get updated risk assessment
        const riskData = await this.migrationMonitor.assessProtocolRisk(protocolName);
        
        // Update position risk
        position.migrationRisk = riskData.overallRisk;
        position.lastRiskUpdate = new Date();
        
        // Log significant risk changes
        if (riskData.overallRisk > this.riskTolerance) {
          console.log(`⚠️  High migration risk detected for ${protocolName}: ${riskData.overallRisk.toFixed(2)}`);
        }
        
      } catch (error) {
        console.error(`Risk update failed for ${protocolName}:`, error);
      }
    }
  }

  calculateRiskAdjustedAllocations() {
    const adjustedAllocations = new Map();
    let totalAdjustedWeight = 0;

    // Calculate risk-adjusted weights
    for (const [protocolName, position] of this.positions) {
      // Risk penalty factor (higher risk = lower allocation)
      const riskPenalty = Math.max(0.1, 1 - position.migrationRisk);
      const adjustedWeight = position.targetAllocation * riskPenalty;
      
      adjustedAllocations.set(protocolName, adjustedWeight);
      totalAdjustedWeight += adjustedWeight;
    }

    // Normalize allocations to sum to 1
    const normalizedAllocations = new Map();
    for (const [protocolName, weight] of adjustedAllocations) {
      normalizedAllocations.set(protocolName, weight / totalAdjustedWeight);
    }

    return normalizedAllocations;
  }

  async rebalancePortfolio() {
    // Update migration risks first
    await this.updateMigrationRisks();

    // Calculate target allocations based on current risks
    const targetAllocations = this.calculateRiskAdjustedAllocations();
    
    const rebalanceActions = [];

    // Determine rebalancing needs
    for (const [protocolName, position] of this.positions) {
      const targetAllocation = targetAllocations.get(protocolName);
      const currentAllocation = position.currentValue / this.totalCapital;
      
      const allocationDifference = targetAllocation - currentAllocation;
      
      // Check if rebalancing is needed
      if (Math.abs(allocationDifference) > this.rebalanceThreshold) {
        const targetValue = targetAllocation * this.totalCapital;
        const rebalanceAmount = targetValue - position.currentValue;
        
        rebalanceActions.push({
          protocol: protocolName,
          action: rebalanceAmount > 0 ? 'BUY' : 'SELL',
          amount: Math.abs(rebalanceAmount),
          currentAllocation: currentAllocation,
          targetAllocation: targetAllocation,
          migrationRisk: position.migrationRisk
        });
      }
    }

    // Execute rebalancing actions
    for (const action of rebalanceActions) {
      await this.executeRebalanceAction(action);
    }

    return rebalanceActions;
  }

  async executeRebalanceAction(action) {
    console.log(`🔄 Rebalancing ${action.protocol}:`);
    console.log(`   Action: ${action.action} ${action.amount.toLocaleString()}`);
    console.log(`   Allocation: ${(action.currentAllocation * 100).toFixed(1)}% → ${(action.targetAllocation * 100).toFixed(1)}%`);
    console.log(`   Migration Risk: ${(action.migrationRisk * 100).toFixed(1)}%`);

    // Update position tracking
    const position = this.positions.get(action.protocol);
    if (action.action === 'BUY') {
      position.currentValue += action.amount;
    } else {
      position.currentValue -= action.amount;
    }
    position.currentAllocation = position.currentValue / this.totalCapital;

    // In real implementation, this would execute actual trades
    // via DEX protocols or centralized exchanges
  }

  generatePortfolioReport() {
    const report = {
      totalValue: this.totalCapital,
      positions: [],
      riskMetrics: this.calculatePortfolioRiskMetrics(),
      recommendations: []
    };

    for (const [protocolName, position] of this.positions) {
      report.positions.push({
        protocol: protocolName,
        value: position.currentValue,
        allocation: position.currentAllocation,
        migrationRisk: position.migrationRisk,
        riskAdjustedReturn: this.calculateRiskAdjustedReturn(position)
      });
    }

    // Generate recommendations
    report.recommendations = this.generateRecommendations(report);

    return report;
  }

  calculatePortfolioRiskMetrics() {
    let weightedRisk = 0;
    let maxRisk = 0;

    for (const [protocolName, position] of this.positions) {
      const positionRisk = position.migrationRisk * position.currentAllocation;
      weightedRisk += positionRisk;
      maxRisk = Math.max(maxRisk, position.migrationRisk);
    }

    return {
      portfolioMigrationRisk: weightedRisk,
      maxPositionRisk: maxRisk,
      riskDiversification: this.calculateRiskDiversification()
    };
  }

  generateRecommendations(report) {
    const recommendations = [];
    
    // High-risk position warnings
    for (const position of report.positions) {
      if (position.migrationRisk > 0.7) {
        recommendations.push({
          type: 'HIGH_RISK_WARNING',
          protocol: position.protocol,
          message: `Consider reducing ${position.protocol} exposure due to high migration risk (${(position.migrationRisk * 100).toFixed(1)}%)`
        });
      }
    }

    // Portfolio concentration warnings
    for (const position of report.positions) {
      if (position.allocation > 0.3) {
        recommendations.push({
          type: 'CONCENTRATION_WARNING',
          protocol: position.protocol,
          message: `${position.protocol} represents ${(position.allocation * 100).toFixed(1)}% of portfolio - consider diversification`
        });
      }
    }

    return recommendations;
  }
}

// Example usage
const portfolioManager = new DeFiPortfolioManager(500000, 0.6); // $500k portfolio, 60% risk tolerance

// Add protocols to portfolio
await portfolioManager.addProtocol('Yearn Finance', 0.3, 0.2);  // 30% target, low risk
await portfolioManager.addProtocol('Compound', 0.25, 0.3);      // 25% target, medium risk  
await portfolioManager.addProtocol('SushiSwap', 0.2, 0.5);      // 20% target, higher risk
await portfolioManager.addProtocol('Curve', 0.25, 0.25);       // 25% target, low-medium risk

// Run daily rebalancing
setInterval(async () => {
  const actions = await portfolioManager.rebalancePortfolio();
  
  if (actions.length > 0) {
    console.log(`📊 Portfolio rebalanced: ${actions.length} actions executed`);
    
    // Generate and log portfolio report
    const report = portfolioManager.generatePortfolioReport();
    console.log(`💰 Total Portfolio Value: ${report.totalValue.toLocaleString()}`);
    console.log(`⚠️  Portfolio Migration Risk: ${(report.riskMetrics.portfolioMigrationRisk * 100).toFixed(1)}%`);
    
    if (report.recommendations.length > 0) {
      console.log('📋 Recommendations:');
      report.recommendations.forEach(rec => console.log(`   - ${rec.message}`));
    }
  }
}, 24 * 60 * 60 * 1000); // Daily rebalancing