How to Track Yield Farming Whale Movements: Large Position Analysis for DeFi Success

# Example whale impact on pool dynamics
initial_tvl = 10_000_000  # $10M pool
whale_deposit = 5_000_000  # $5M whale entry
new_tvl = initial_tvl + whale_deposit

# APY reduction calculation
initial_apy = 25.0  # 25% APY
new_apy = initial_apy * (initial_tvl / new_tvl)
print(f"APY drops from {initial_apy}% to {new_apy:.1f}%")
# Output: APY drops from 25.0% to 16.7%

-- Track large yield farming positions
SELECT 
    user_address,
    protocol_name,
    pool_name,
    deposit_amount_usd,
    transaction_hash,
    block_timestamp
FROM defi_positions 
WHERE deposit_amount_usd > 1000000  -- $1M+ positions
AND block_timestamp > NOW() - INTERVAL '24 hours'
ORDER BY deposit_amount_usd DESC

// Monitor protocol TVL changes
const protocolData = await fetch('https://api.llama.fi/protocol/aave');
const tvlHistory = protocolData.chart;

// Detect significant TVL spikes (potential whale activity)
const significantChanges = tvlHistory.filter((day, index) => {
    if (index === 0) return false;
    const previousDay = tvlHistory[index - 1];
    const changePercent = ((day.totalLiquidityUSD - previousDay.totalLiquidityUSD) / previousDay.totalLiquidityUSD) * 100;
    return Math.abs(changePercent) > 10; // 10%+ daily change
});

# Python script to track whale transactions
import requests
import json

def get_whale_transactions(address, min_value_usd=100000):
    """
    Fetch large transactions for a whale address
    """
    api_key = "YOUR_ETHERSCAN_API_KEY"
    url = f"https://api.etherscan.io/api"
    
    params = {
        'module': 'account',
        'action': 'txlist',
        'address': address,
        'startblock': 0,
        'endblock': 99999999,
        'sort': 'desc',
        'apikey': api_key
    }
    
    response = requests.get(url, params=params)
    transactions = response.json()['result']
    
    # Filter for high-value transactions
    whale_txs = [tx for tx in transactions 
                 if int(tx['value']) / 1e18 > min_value_usd / 3000]  # Assuming $3000 ETH
    
    return whale_txs[:10]  # Return latest 10 whale transactions

from web3 import Web3
import asyncio
import logging

class WhaleTracker:
    def __init__(self, rpc_url, min_threshold_usd=500000):
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        self.min_threshold = min_threshold_usd
        self.known_whales = self.load_whale_addresses()
    
    def load_whale_addresses(self):
        """Load known whale addresses from various sources"""
        return [
            "0x47ac0Fb4F2D84898e4D9E7b4DaB3C24507a6D503",  # Binance
            "0x8315177aB297bA92A06054cE80a67Ed4DBd7ed3a",  # Bitfinex
            # Add more whale addresses
        ]
    
    async def monitor_transactions(self):
        """Monitor pending transactions for whale activity"""
        latest_block = self.w3.eth.block_number
        
        while True:
            try:
                current_block = self.w3.eth.block_number
                
                if current_block > latest_block:
                    block = self.w3.eth.get_block(current_block, True)
                    
                    for tx in block.transactions:
                        await self.analyze_transaction(tx)
                    
                    latest_block = current_block
                
                await asyncio.sleep(2)  # Check every 2 seconds
                
            except Exception as e:
                logging.error(f"Error monitoring transactions: {e}")
                await asyncio.sleep(10)
    
    async def analyze_transaction(self, tx):
        """Analyze transaction for whale yield farming activity"""
        if tx['from'] in self.known_whales or tx['to'] in self.known_whales:
            # Check if transaction involves DeFi protocols
            if self.is_defi_transaction(tx):
                value_usd = self.calculate_usd_value(tx['value'])
                
                if value_usd > self.min_threshold:
                    await self.send_alert({
                        'type': 'whale_movement',
                        'whale_address': tx['from'],
                        'value_usd': value_usd,
                        'protocol': self.identify_protocol(tx['to']),
                        'tx_hash': tx['hash'].hex()
                    })

import discord
from discord.ext import commands
import aiohttp

class WhaleAlertBot(commands.Bot):
    def __init__(self):
        super().__init__(command_prefix='!')
        self.webhook_url = "YOUR_DISCORD_WEBHOOK_URL"
    
    async def send_whale_alert(self, alert_data):
        """Send formatted whale alert to Discord"""
        embed = discord.Embed(
            title="🐋 Whale Movement Detected",
            color=0x00ff00 if alert_data['type'] == 'entry' else 0xff0000
        )
        
        embed.add_field(
            name="Whale Address", 
            value=f"`{alert_data['whale_address'][:10]}...`", 
            inline=True
        )
        embed.add_field(
            name="Value", 
            value=f"${alert_data['value_usd']:,.0f}", 
            inline=True
        )
        embed.add_field(
            name="Protocol", 
            value=alert_data['protocol'], 
            inline=True
        )
        embed.add_field(
            name="Transaction", 
            value=f"[View on Etherscan](https://etherscan.io/tx/{alert_data['tx_hash']})", 
            inline=False
        )
        
        async with aiohttp.ClientSession() as session:
            webhook = discord.Webhook.from_url(self.webhook_url, session=session)
            await webhook.send(embed=embed)

def classify_position_size(amount_usd, pool_tvl_usd):
    """
    Classify DeFi position size and potential market impact
    """
    position_ratio = amount_usd / pool_tvl_usd
    
    if amount_usd >= 10_000_000:  # $10M+
        return "Mega Whale", "Extreme Impact"
    elif amount_usd >= 5_000_000:  # $5M+
        return "Large Whale", "High Impact"
    elif amount_usd >= 1_000_000:  # $1M+
        return "Medium Whale", "Moderate Impact"
    elif position_ratio > 0.05:  # >5% of pool
        return "Small Whale", "Pool Specific Impact"
    else:
        return "Large Fish", "Minimal Impact"

# Example usage
position_amount = 2_500_000  # $2.5M
pool_tvl = 50_000_000  # $50M pool
whale_type, impact = classify_position_size(position_amount, pool_tvl)
print(f"Classification: {whale_type} with {impact}")
# Output: Classification: Medium Whale with Moderate Impact

import pandas as pd
import matplotlib.pyplot as plt

def analyze_whale_timing(whale_transactions):
    """
    Analyze whale entry/exit timing patterns
    """
    df = pd.DataFrame(whale_transactions)
    df['timestamp'] = pd.to_datetime(df['timestamp'])
    df['hour'] = df['timestamp'].dt.hour
    df['day_of_week'] = df['timestamp'].dt.day_name()
    
    # Most active hours
    hourly_activity = df['hour'].value_counts().sort_index()
    
    # Most active days
    daily_activity = df['day_of_week'].value_counts()
    
    # Average position hold time
    df_sorted = df.sort_values(['whale_address', 'timestamp'])
    df_sorted['position_duration'] = df_sorted.groupby('whale_address')['timestamp'].diff()
    avg_hold_time = df_sorted['position_duration'].mean()
    
    return {
        'peak_hours': hourly_activity.nlargest(3).index.tolist(),
        'peak_days': daily_activity.nlargest(2).index.tolist(),
        'avg_hold_time': avg_hold_time,
        'total_movements': len(df)
    }

// Solidity interface to query Uniswap V3 positions
interface INonfungiblePositionManager {
    struct Position {
        uint96 nonce;
        address operator;
        address token0;
        address token1;
        uint24 fee;
        int24 tickLower;
        int24 tickUpper;
        uint128 liquidity;
        uint256 feeGrowthInside0LastX128;
        uint256 feeGrowthInside1LastX128;
        uint128 tokensOwed0;
        uint128 tokensOwed1;
    }
    
    function positions(uint256 tokenId) external view returns (Position memory);
}

# Python script to track Uniswap V3 whale positions
from web3 import Web3
import json

def get_whale_uniswap_positions(whale_address, min_liquidity_usd=100000):
    """
    Get whale's Uniswap V3 positions above threshold
    """
    w3 = Web3(Web3.HTTPProvider("YOUR_RPC_URL"))
    
    # Uniswap V3 Position Manager contract
    position_manager_address = "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
    
    # Query events for position creation/modification
    filter_params = {
        'fromBlock': 'latest-1000',  # Last 1000 blocks
        'toBlock': 'latest',
        'address': position_manager_address,
        'topics': [
            '0x3067048beee31b25b2f1681f88dac838c8bba36af25bfb2b7cf7473a5847e35f',  # IncreaseLiquidity
            whale_address
        ]
    }
    
    events = w3.eth.get_logs(filter_params)
    
    # Parse and filter significant positions
    significant_positions = []
    
    for event in events:
        # Decode event data and check position size
        # Implementation depends on specific ABI parsing
        pass
    
    return significant_positions

def monitor_aave_whale_activity():
    """
    Monitor Aave for whale lending/borrowing activity
    """
    # Aave V3 Pool contract events
    deposit_signature = "0xde6857219544bb5b7746f48ed30be6386fefc61b2f864cacf559893bf50fd951"
    withdraw_signature = "0x3115d1449a7b732c986cba18244e897a450f61e1bb8d589cd2e69e6c8924f9f7"
    
    recent_events = get_contract_events(
        contract_address="0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2",  # Aave V3 Pool
        event_signatures=[deposit_signature, withdraw_signature],
        min_value_threshold=500000  # $500K minimum
    )
    
    return parse_whale_events(recent_events)

def track_curve_whale_strategies():
    """
    Track Curve Finance whale strategies across pools
    """
    curve_pools = [
        "0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7",  # 3Pool
        "0xDC24316b9AE028F1497c275EB9192a3Ea0f67022",  # stETH
        "0xD51a44d3FaE010294C616388b506AcdA1bfAAE46",  # Tricrypto
    ]
    
    whale_activities = []
    
    for pool in curve_pools:
        # Monitor AddLiquidity and RemoveLiquidity events
        activities = get_curve_liquidity_events(
            pool_address=pool,
            min_amount_threshold=1000000,  # $1M threshold
            time_window="24h"
        )
        whale_activities.extend(activities)
    
    return analyze_curve_patterns(whale_activities)

class WhaleFollower:
    def __init__(self, whale_addresses, follow_ratio=0.01):
        self.whales = whale_addresses
        self.follow_ratio = follow_ratio  # Follow with 1% of whale size
        self.active_positions = {}
    
    async def process_whale_movement(self, whale_alert):
        """
        Process whale movement and execute copy trade
        """
        whale_addr = whale_alert['whale_address']
        action = whale_alert['action']  # 'enter' or 'exit'
        protocol = whale_alert['protocol']
        amount_usd = whale_alert['amount_usd']
        
        if whale_addr in self.whales:
            copy_amount = amount_usd * self.follow_ratio
            
            if action == 'enter':
                await self.execute_entry(protocol, copy_amount, whale_alert)
            elif action == 'exit':
                await self.execute_exit(protocol, whale_addr)
    
    async def execute_entry(self, protocol, amount, whale_data):
        """Execute copy trade entry"""
        # Implement protocol-specific entry logic
        position_id = f"{protocol}_{whale_data['pool_address']}"
        
        # Add safety checks
        if self.validate_protocol_safety(protocol):
            # Execute trade via DEX aggregator
            tx_hash = await self.place_trade(
                protocol=protocol,
                amount=amount,
                pool=whale_data['pool_address']
            )
            
            self.active_positions[position_id] = {
                'entry_tx': tx_hash,
                'amount': amount,
                'whale_followed': whale_data['whale_address'],
                'entry_time': whale_data['timestamp']
            }

def calculate_whale_following_risk(whale_history, market_conditions):
    """
    Calculate risk metrics for following specific whales
    """
    # Whale success rate
    successful_trades = sum(1 for trade in whale_history if trade['profit'] > 0)
    success_rate = successful_trades / len(whale_history)
    
    # Average hold time
    avg_hold_days = sum(trade['hold_days'] for trade in whale_history) / len(whale_history)
    
    # Maximum drawdown
    cumulative_returns = []
    running_return = 1.0
    
    for trade in whale_history:
        running_return *= (1 + trade['return_pct'] / 100)
        cumulative_returns.append(running_return)
    
    peak = cumulative_returns[0]
    max_drawdown = 0
    
    for value in cumulative_returns:
        if value > peak:
            peak = value
        drawdown = (peak - value) / peak
        max_drawdown = max(max_drawdown, drawdown)
    
    # Risk score calculation
    volatility = calculate_volatility(whale_history)
    
    risk_score = {
        'success_rate': success_rate,
        'avg_hold_days': avg_hold_days,
        'max_drawdown': max_drawdown,
        'volatility': volatility,
        'sharpe_ratio': calculate_sharpe_ratio(whale_history),
        'recommendation': 'FOLLOW' if success_rate > 0.6 and max_drawdown < 0.3 else 'AVOID'
    }
    
    return risk_score

import pandas as pd
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
import numpy as np

def classify_whale_behavior(transaction_data):
    """
    Use machine learning to classify whale trading patterns
    """
    # Feature engineering
    features = []
    
    for whale in transaction_data:
        whale_features = {
            'avg_position_size': np.mean(whale['position_sizes']),
            'position_frequency': len(whale['transactions']) / whale['active_days'],
            'protocol_diversity': len(set(whale['protocols'])),
            'avg_hold_time': np.mean(whale['hold_times']),
            'profit_ratio': whale['successful_trades'] / len(whale['transactions']),
            'gas_efficiency': np.mean(whale['gas_costs']) / np.mean(whale['position_sizes']),
            'timing_score': calculate_timing_score(whale['entry_times'])
        }
        features.append(whale_features)
    
    df = pd.DataFrame(features)
    
    # Normalize features
    scaler = StandardScaler()
    scaled_features = scaler.fit_transform(df)
    
    # Cluster analysis
    kmeans = KMeans(n_clusters=5, random_state=42)
    clusters = kmeans.fit_predict(scaled_features)
    
    # Define cluster characteristics
    cluster_names = {
        0: "Conservative Yield Farmers",
        1: "Aggressive Yield Hunters", 
        2: "Arbitrage Specialists",
        3: "Long-term Liquidity Providers",
        4: "High-frequency Protocol Jumpers"
    }
    
    df['cluster'] = clusters
    df['whale_type'] = df['cluster'].map(cluster_names)
    
    return df

class MultiChainWhaleTracker:
    def __init__(self):
        self.chain_rpcs = {
            'ethereum': "https://eth-mainnet.g.alchemy.com/v2/YOUR-KEY",
            'polygon': "https://polygon-mainnet.g.alchemy.com/v2/YOUR-KEY", 
            'arbitrum': "https://arb-mainnet.g.alchemy.com/v2/YOUR-KEY",
            'optimism': "https://opt-mainnet.g.alchemy.com/v2/YOUR-KEY"
        }
        
        self.whale_addresses = self.load_cross_chain_whales()
    
    async def track_cross_chain_movements(self, whale_address):
        """
        Track whale movements across all supported chains
        """
        all_activities = {}
        
        for chain, rpc_url in self.chain_rpcs.items():
            try:
                activities = await self.get_chain_activities(
                    whale_address, 
                    chain, 
                    rpc_url
                )
                all_activities[chain] = activities
            except Exception as e:
                print(f"Error tracking {chain}: {e}")
        
        # Analyze cross-chain patterns
        return self.analyze_cross_chain_strategy(all_activities)
    
    def analyze_cross_chain_strategy(self, activities):
        """
        Analyze whale's cross-chain yield farming strategy
        """
        strategy_insights = {
            'primary_chain': self.find_primary_chain(activities),
            'arbitrage_opportunities': self.detect_arbitrage(activities),
            'yield_optimization': self.analyze_yield_chasing(activities),
            'gas_efficiency': self.calculate_gas_optimization(activities)
        }
        
        return strategy_insights

import streamlit as st
import plotly.graph_objects as go
import plotly.express as px
from datetime import datetime, timedelta

def create_whale_dashboard():
    """
    Create interactive whale tracking dashboard
    """
    st.set_page_config(
        page_title="DeFi Whale Tracker",
        page_icon="🐋",
        layout="wide"
    )
    
    st.title("🐋 DeFi Whale Movement Tracker")
    
    # Sidebar controls
    st.sidebar.header("Tracking Filters")
    min_position_size = st.sidebar.slider(
        "Minimum Position Size (USD)", 
        100000, 10000000, 1000000
    )
    
    selected_protocols = st.sidebar.multiselect(
        "Protocols to Monitor",
        ["Uniswap", "Aave", "Compound", "Curve", "Yearn"],
        default=["Uniswap", "Aave"]
    )
    
    time_range = st.sidebar.selectbox(
        "Time Range",
        ["24 hours", "7 days", "30 days"],
        index=1
    )
    
    # Main dashboard
    col1, col2, col3, col4 = st.columns(4)
    
    with col1:
        st.metric(
            label="Active Whales",
            value="247",
            delta="+12 from yesterday"
        )
    
    with col2:
        st.metric(
            label="Total Whale TVL", 
            value="$2.4B",
            delta="+$180M (8.1%)"
        )
    
    with col3:
        st.metric(
            label="Avg Position Size",
            value="$3.2M", 
            delta="-$400K (-11%)"
        )
    
    with col4:
        st.metric(
            label="New Positions Today",
            value="23",
            delta="+7 from yesterday"
        )
    
    # Charts
    col1, col2 = st.columns(2)
    
    with col1:
        st.subheader("Whale Activity Timeline")
        # Create mock data for demo
        timeline_data = create_timeline_chart()
        st.plotly_chart(timeline_data, use_container_width=True)
    
    with col2:
        st.subheader("Protocol Distribution")
        protocol_data = create_protocol_pie_chart()
        st.plotly_chart(protocol_data, use_container_width=True)
    
    # Recent whale movements table
    st.subheader("Recent Whale Movements")
    whale_movements = load_recent_movements(min_position_size, selected_protocols)
    st.dataframe(whale_movements, use_container_width=True)

if __name__ == "__main__":
    create_whale_dashboard()

class AlertManager:
    def __init__(self):
        self.alert_channels = {
            'discord': DiscordWebhook("YOUR_WEBHOOK_URL"),
            'telegram': TelegramBot("YOUR_BOT_TOKEN"),
            'email': EmailClient("YOUR_SMTP_CONFIG")
        }
        
        self.alert_rules = []
    
    def add_alert_rule(self, rule_config):
        """
        Add custom alert rule for whale tracking
        """
        rule = {
            'name': rule_config['name'],
            'conditions': rule_config['conditions'],
            'channels': rule_config['channels'],
            'cooldown': rule_config.get('cooldown', 300),  # 5 min default
            'last_triggered': None
        }
        
        self.alert_rules.append(rule)
    
    async def check_alerts(self, whale_data):
        """
        Check whale data against all alert rules
        """
        for rule in self.alert_rules:
            if self.evaluate_conditions(whale_data, rule['conditions']):
                if self.check_cooldown(rule):
                    await self.send_alert(rule, whale_data)
                    rule['last_triggered'] = datetime.now()
    
    def evaluate_conditions(self, data, conditions):
        """
        Evaluate alert conditions against whale data
        """
        for condition in conditions:
            field = condition['field']
            operator = condition['operator']
            value = condition['value']
            
            data_value = data.get(field)
            
            if operator == 'greater_than' and data_value <= value:
                return False
            elif operator == 'less_than' and data_value >= value:
                return False
            elif operator == 'equals' and data_value != value:
                return False
            # Add more operators as needed
        
        return True

# Example alert rule configuration
alert_manager = AlertManager()

alert_manager.add_alert_rule({
    'name': 'Large Uniswap Entry',
    'conditions': [
        {'field': 'protocol', 'operator': 'equals', 'value': 'Uniswap'},
        {'field': 'position_size_usd', 'operator': 'greater_than', 'value': 5000000},
        {'field': 'action', 'operator': 'equals', 'value': 'entry'}
    ],
    'channels': ['discord', 'telegram'],
    'cooldown': 600  # 10 minutes
})

def calculate_safe_follow_size(portfolio_value, whale_position, risk_tolerance=0.05):
    """
    Calculate safe position size for whale following
    """
    max_risk_amount = portfolio_value * risk_tolerance
    
    # Consider whale position as percentage of their total portfolio
    estimated_whale_portfolio = whale_position / 0.1  # Assume 10% allocation
    follow_ratio = max_risk_amount / whale_position
    
    # Additional safety factors
    protocol_risk_multiplier = {
        'established': 1.0,  # Uniswap, Aave, Compound
        'newer': 0.5,        # Newer protocols
        'experimental': 0.25  # Highly experimental
    }
    
    safe_amount = min(max_risk_amount, whale_position * follow_ratio)
    
    return {
        'recommended_amount': safe_amount,
        'follow_ratio': follow_ratio,
        'risk_percentage': (safe_amount / portfolio_value) * 100,
        'warnings': generate_risk_warnings(whale_position, safe_amount)
    }

def filter_genuine_whale_signals(whale_transactions):
    """
    Filter out false whale signals like rebalancing or arbitrage
    """
    genuine_signals = []
    
    for tx in whale_transactions:
        # Skip if transaction is likely rebalancing
        if is_likely_rebalancing(tx):
            continue
            
        # Skip MEV/arbitrage transactions
        if is_mev_transaction(tx):
            continue
            
        # Skip automatic DCA or scheduled transactions
        if is_automated_transaction(tx):
            continue
            
        # Verify transaction has significant duration
        if tx.get('expected_hold_time', 0) < 24:  # Less than 24 hours
            continue
            
        genuine_signals.append(tx)
    
    return genuine_signals

def is_likely_rebalancing(transaction):
    """Check if transaction is likely portfolio rebalancing"""
    # Multiple rapid transactions across protocols
    # Similar amounts entering/exiting
    # Same whale address across multiple simultaneous transactions
    return False  # Implement logic based on patterns

def is_mev_transaction(transaction):
    """Identify MEV/arbitrage transactions"""
    # Very short hold times
    # Immediate profit realization
    # Flash loan usage patterns
    return False  # Implement MEV detection logic

class WhaleFollowingTracker:
    def __init__(self):
        self.positions = []
        self.performance_metrics = {}
    
    def record_position(self, whale_followed, entry_data, exit_data=None):
        """Record whale following position for analysis"""
        position = {
            'whale_address': whale_followed,
            'protocol': entry_data['protocol'],
            'entry_price': entry_data['price'],
            'entry_amount': entry_data['amount'],
            'entry_time': entry_data['timestamp'],
            'exit_price': exit_data['price'] if exit_data else None,
            'exit_time': exit_data['timestamp'] if exit_data else None,
            'status': 'closed' if exit_data else 'open'
        }
        
        if exit_data:
            position['profit_loss'] = self.calculate_pnl(entry_data, exit_data)
            position['hold_duration'] = exit_data['timestamp'] - entry_data['timestamp']
        
        self.positions.append(position)
    
    def generate_performance_report(self):
        """Generate comprehensive performance analysis"""
        closed_positions = [p for p in self.positions if p['status'] == 'closed']
        
        if not closed_positions:
            return {"error": "No closed positions to analyze"}
        
        profits = [p['profit_loss'] for p in closed_positions]
        
        report = {
            'total_trades': len(closed_positions),
            'winning_trades': len([p for p in profits if p > 0]),
            'win_rate': len([p for p in profits if p > 0]) / len(profits),
            'total_pnl': sum(profits),
            'average_profit': sum(profits) / len(profits),
            'best_trade': max(profits),
            'worst_trade': min(profits),
            'avg_hold_time': sum(p['hold_duration'].total_seconds() for p in closed_positions) / len(closed_positions) / 3600,  # Hours
            'whale_performance': self.analyze_by_whale(closed_positions)
        }
        
        return report