How to Use Zapper.fi for Stablecoin DeFi: My One-Click Position Management Journey

# zapper_integration.py
import asyncio
import aiohttp
import logging
from dataclasses import dataclass
from typing import Dict, List, Optional, Tuple
import time
import json
from decimal import Decimal, ROUND_HALF_UP

@dataclass
class StablecoinPosition:
    protocol: str
    pool_address: str
    token_symbols: List[str]
    balance_usd: float
    apy: float
    rewards_usd: float
    health_factor: Optional[float]
    position_type: str  # 'lending', 'liquidity', 'vault', 'staking'
    
@dataclass
class YieldOpportunity:
    protocol: str
    pool_address: str
    token_symbol: str
    current_apy: float
    category: str
    risk_score: float
    liquidity_usd: float
    entry_gas_cost: float

class ZapperStablecoinManager:
    def __init__(self, api_key: str, wallet_address: str):
        self.api_key = api_key
        self.wallet_address = wallet_address.lower()
        self.base_url = "https://api.zapper.fi"
        self.session = None
        
        # Position tracking
        self.current_positions = {}
        self.yield_targets = {}
        self.rebalancing_rules = {}
        
        # Stablecoin focus
        self.target_stablecoins = ['USDC', 'USDT', 'DAI', 'FRAX', 'LUSD']
        self.min_apy_threshold = 0.05  # 5% minimum APY
        self.max_risk_score = 7.0      # Maximum risk tolerance (1-10 scale)
        
    async def initialize_session(self):
        """Initialize HTTP session with proper headers"""
        
        self.session = aiohttp.ClientSession(
            headers={
                'Authorization': f'Basic {self.api_key}',
                'Content-Type': 'application/json'
            },
            timeout=aiohttp.ClientTimeout(total=30)
        )
    
    async def get_portfolio_overview(self) -> Dict:
        """Get comprehensive portfolio overview from Zapper"""
        
        try:
            url = f"{self.base_url}/v2/balances"
            params = {
                'addresses[]': self.wallet_address,
                'networks[]': ['ethereum', 'polygon', 'arbitrum', 'optimism']
            }
            
            async with self.session.get(url, params=params) as response:
                if response.status == 200:
                    data = await response.json()
                    return self.parse_portfolio_data(data)
                else:
                    logging.error(f"Failed to fetch portfolio: {response.status}")
                    return {}
                    
        except Exception as e:
            logging.error(f"Portfolio fetch error: {e}")
            return {}
    
    def parse_portfolio_data(self, raw_data: Dict) -> Dict:
        """Parse raw Zapper data into structured portfolio information"""
        
        portfolio = {
            'total_balance_usd': 0,
            'stablecoin_positions': [],
            'protocol_breakdown': {},
            'yield_summary': {
                'total_apy': 0,
                'weighted_apy': 0,
                'daily_rewards': 0
            }
        }
        
        for network_data in raw_data.values():
            for protocol_name, protocol_data in network_data.items():
                if not isinstance(protocol_data, dict) or 'products' not in protocol_data:
                    continue
                    
                for product in protocol_data['products']:
                    positions = self.extract_stablecoin_positions(protocol_name, product)
                    portfolio['stablecoin_positions'].extend(positions)
                    
                    # Update protocol breakdown
                    if protocol_name not in portfolio['protocol_breakdown']:
                        portfolio['protocol_breakdown'][protocol_name] = {
                            'balance_usd': 0,
                            'positions': 0,
                            'avg_apy': 0
                        }
                    
                    for position in positions:
                        portfolio['total_balance_usd'] += position.balance_usd
                        portfolio['protocol_breakdown'][protocol_name]['balance_usd'] += position.balance_usd
                        portfolio['protocol_breakdown'][protocol_name]['positions'] += 1
        
        # Calculate weighted APY
        if portfolio['total_balance_usd'] > 0:
            total_yield = sum(
                pos.balance_usd * pos.apy 
                for pos in portfolio['stablecoin_positions']
            )
            portfolio['yield_summary']['weighted_apy'] = total_yield / portfolio['total_balance_usd']
            portfolio['yield_summary']['daily_rewards'] = total_yield / 365
        
        return portfolio
    
    def extract_stablecoin_positions(self, protocol: str, product_data: Dict) -> List[StablecoinPosition]:
        """Extract stablecoin-focused positions from protocol data"""
        
        positions = []
        
        if 'assets' not in product_data:
            return positions
        
        for asset in product_data['assets']:
            # Check if this involves stablecoins
            token_symbols = []
            if 'tokens' in asset:
                token_symbols = [token.get('symbol', '') for token in asset['tokens']]
            elif 'symbol' in asset:
                token_symbols = [asset['symbol']]
            
            # Filter for stablecoin positions
            stablecoin_tokens = [
                symbol for symbol in token_symbols 
                if symbol in self.target_stablecoins
            ]
            
            if not stablecoin_tokens:
                continue
                
            # Extract position details
            balance_usd = asset.get('balanceUSD', 0)
            if balance_usd < 10:  # Skip dust positions
                continue
            
            position = StablecoinPosition(
                protocol=protocol,
                pool_address=asset.get('address', ''),
                token_symbols=stablecoin_tokens,
                balance_usd=balance_usd,
                apy=self.extract_apy(asset),
                rewards_usd=asset.get('claimableUSD', 0),
                health_factor=asset.get('healthFactor'),
                position_type=self.categorize_position_type(protocol, asset)
            )
            
            positions.append(position)
        
        return positions
    
    def extract_apy(self, asset_data: Dict) -> float:
        """Extract APY from various possible fields"""
        
        # Zapper uses different field names for APY across protocols
        apy_fields = ['apy', 'supplyApy', 'totalApy', 'farmApy', 'poolApy']
        
        for field in apy_fields:
            if field in asset_data and asset_data[field]:
                try:
                    return float(asset_data[field])
                except (ValueError, TypeError):
                    continue
        
        # If no direct APY, try to calculate from rewards
        if 'rewardsUSD' in asset_data and 'balanceUSD' in asset_data:
            balance = asset_data['balanceUSD']
            if balance > 0:
                # Assume rewards are annual
                return asset_data['rewardsUSD'] / balance
        
        return 0.0
    
    def categorize_position_type(self, protocol: str, asset_data: Dict) -> str:
        """Categorize the type of DeFi position"""
        
        protocol_lower = protocol.lower()
        
        if 'aave' in protocol_lower or 'compound' in protocol_lower:
            return 'lending'
        elif 'uniswap' in protocol_lower or 'curve' in protocol_lower or 'balancer' in protocol_lower:
            return 'liquidity'
        elif 'yearn' in protocol_lower or 'harvest' in protocol_lower:
            return 'vault'
        elif 'staking' in str(asset_data).lower():
            return 'staking'
        else:
            return 'other'
    
    async def find_yield_opportunities(self, min_amount: float = 1000) -> List[YieldOpportunity]:
        """Find high-yield opportunities for stablecoins"""
        
        try:
            url = f"{self.base_url}/v2/pool/stats"
            
            opportunities = []
            
            # Query multiple networks for opportunities
            networks = ['ethereum', 'polygon', 'arbitrum', 'optimism']
            
            for network in networks:
                params = {
                    'network': network,
                    'poolTypes[]': ['liquidity-pool', 'lending-pool', 'vault'],
                    'minLiquidity': min_amount
                }
                
                async with self.session.get(url, params=params) as response:
                    if response.status == 200:
                        data = await response.json()
                        network_opportunities = self.parse_yield_opportunities(data, network)
                        opportunities.extend(network_opportunities)
            
            # Filter and sort opportunities
            filtered_opportunities = [
                opp for opp in opportunities
                if (opp.current_apy >= self.min_apy_threshold and 
                    opp.risk_score <= self.max_risk_score and
                    opp.token_symbol in self.target_stablecoins)
            ]
            
            # Sort by risk-adjusted yield
            filtered_opportunities.sort(
                key=lambda x: x.current_apy / x.risk_score, 
                reverse=True
            )
            
            return filtered_opportunities[:20]  # Top 20 opportunities
            
        except Exception as e:
            logging.error(f"Error finding yield opportunities: {e}")
            return []
    
    def parse_yield_opportunities(self, pool_data: Dict, network: str) -> List[YieldOpportunity]:
        """Parse pool data into yield opportunities"""
        
        opportunities = []
        
        for pool in pool_data.get('pools', []):
            try:
                # Extract token information
                tokens = pool.get('tokens', [])
                stablecoin_tokens = [
                    token['symbol'] for token in tokens
                    if token.get('symbol') in self.target_stablecoins
                ]
                
                if not stablecoin_tokens:
                    continue
                
                # Calculate risk score based on protocol and pool characteristics
                risk_score = self.calculate_pool_risk_score(pool)
                
                for token_symbol in stablecoin_tokens:
                    opportunity = YieldOpportunity(
                        protocol=pool.get('appName', 'Unknown'),
                        pool_address=pool.get('address', ''),
                        token_symbol=token_symbol,
                        current_apy=pool.get('apy', 0),
                        category=pool.get('category', 'other'),
                        risk_score=risk_score,
                        liquidity_usd=pool.get('liquidity', 0),
                        entry_gas_cost=self.estimate_gas_cost(network, pool.get('appName', ''))
                    )
                    
                    opportunities.append(opportunity)
                    
            except Exception as e:
                logging.warning(f"Error parsing pool data: {e}")
                continue
        
        return opportunities
    
    def calculate_pool_risk_score(self, pool_data: Dict) -> float:
        """Calculate risk score for a yield opportunity (1-10 scale)"""
        
        risk_score = 5.0  # Base risk score
        
        # Protocol reputation adjustment
        protocol = pool_data.get('appName', '').lower()
        if protocol in ['aave', 'compound', 'uniswap']:
            risk_score -= 2.0  # Lower risk for blue-chip protocols
        elif protocol in ['curve', 'balancer', 'yearn']:
            risk_score -= 1.0  # Slightly lower risk
        elif protocol in ['sushiswap', '1inch']:
            risk_score += 0.5  # Slightly higher risk
        
        # Liquidity adjustment
        liquidity = pool_data.get('liquidity', 0)
        if liquidity > 100_000_000:  # $100M+
            risk_score -= 1.0
        elif liquidity > 10_000_000:  # $10M+
            risk_score -= 0.5
        elif liquidity < 1_000_000:  # <$1M
            risk_score += 1.5
        
        # APY adjustment (extremely high APY = higher risk)
        apy = pool_data.get('apy', 0)
        if apy > 0.5:  # 50%+ APY
            risk_score += 2.0
        elif apy > 0.2:  # 20%+ APY
            risk_score += 1.0
        
        # Token composition risk
        tokens = pool_data.get('tokens', [])
        if len(tokens) > 4:  # Complex pools have higher risk
            risk_score += 1.0
        
        return max(1.0, min(10.0, risk_score))
    
    def estimate_gas_cost(self, network: str, protocol: str) -> float:
        """Estimate gas cost for entering a position"""
        
        # Base gas estimates in USD
        base_costs = {
            'ethereum': 25.0,    # Higher gas costs
            'polygon': 0.5,      # Very low costs
            'arbitrum': 2.0,     # Low costs
            'optimism': 2.0      # Low costs
        }
        
        # Protocol-specific multipliers
        protocol_multipliers = {
            'uniswap': 1.2,      # Slightly higher
            'curve': 1.5,        # More complex
            'balancer': 1.3,     # Moderately complex
            'aave': 1.0,         # Standard
            'compound': 1.0      # Standard
        }
        
        base_cost = base_costs.get(network, 10.0)
        multiplier = protocol_multipliers.get(protocol.lower(), 1.0)
        
        return base_cost * multiplier

// StablecoinDashboard.tsx
import React, { useState, useEffect } from 'react';
import { LineChart, Line, XAxis, YAxis, CartesianGrid, Tooltip, ResponsiveContainer, PieChart, Pie, Cell } from 'recharts';

interface Position {
  protocol: string;
  tokenSymbols: string[];
  balanceUsd: number;
  apy: number;
  rewardsUsd: number;
  healthFactor?: number;
  positionType: string;
}

interface YieldOpportunity {
  protocol: string;
  tokenSymbol: string;
  currentApy: number;
  riskScore: number;
  liquidityUsd: number;
  entryGasCost: number;
}

const StablecoinDashboard: React.FC = () => {
  const [positions, setPositions] = useState<Position[]>([]);
  const [opportunities, setOpportunities] = useState<YieldOpportunity[]>([]);
  const [portfolioMetrics, setPortfolioMetrics] = useState({
    totalBalance: 0,
    weightedApy: 0,
    dailyRewards: 0,
    riskScore: 0
  });
  const [loading, setLoading] = useState(true);
  
  useEffect(() => {
    loadDashboardData();
    
    // Auto-refresh every 5 minutes
    const interval = setInterval(loadDashboardData, 300000);
    return () => clearInterval(interval);
  }, []);
  
  const loadDashboardData = async () => {
    try {
      setLoading(true);
      
      // Fetch data from our Zapper integration
      const response = await fetch('/api/stablecoin-dashboard');
      const data = await response.json();
      
      setPositions(data.positions || []);
      setOpportunities(data.opportunities || []);
      setPortfolioMetrics(data.metrics || {});
      
    } catch (error) {
      console.error('Failed to load dashboard data:', error);
    } finally {
      setLoading(false);
    }
  };
  
  const executeRebalance = async (fromProtocol: string, toProtocol: string, amount: number) => {
    try {
      setLoading(true);
      
      const response = await fetch('/api/execute-rebalance', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          fromProtocol,
          toProtocol,
          amount,
          slippage: 0.5 // 0.5% slippage tolerance
        })
      });
      
      if (response.ok) {
        await loadDashboardData(); // Refresh after rebalance
      }
      
    } catch (error) {
      console.error('Rebalance failed:', error);
    } finally {
      setLoading(false);
    }
  };
  
  // Calculate protocol distribution for pie chart
  const protocolDistribution = positions.reduce((acc, position) => {
    const existing = acc.find(item => item.name === position.protocol);
    if (existing) {
      existing.value += position.balanceUsd;
    } else {
      acc.push({ name: position.protocol, value: position.balanceUsd });
    }
    return acc;
  }, [] as { name: string; value: number }[]);
  
  // Colors for pie chart
  const COLORS = ['#0088FE', '#00C49F', '#FFBB28', '#FF8042', '#8884D8', '#82CA9D'];
  
  if (loading) {
    return (
      <div className="flex items-center justify-center min-h-screen">
        <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-blue-600"></div>
      </div>
    );
  }
  
  return (
    <div className="min-h-screen bg-gray-50 p-6">
      <div className="max-w-7xl mx-auto">
        <h1 className="text-3xl font-bold text-gray-900 mb-8">Stablecoin DeFi Dashboard</h1>
        
        {/* Key Metrics */}
        <div className="grid grid-cols-1 md:grid-cols-4 gap-6 mb-8">
          <div className="bg-white rounded-lg shadow p-6">
            <h3 className="text-sm font-medium text-gray-500">Total Balance</h3>
            <p className="text-2xl font-bold text-gray-900">
              ${portfolioMetrics.totalBalance.toLocaleString()}
            </p>
          </div>
          
          <div className="bg-white rounded-lg shadow p-6">
            <h3 className="text-sm font-medium text-gray-500">Weighted APY</h3>
            <p className="text-2xl font-bold text-green-600">
              {(portfolioMetrics.weightedApy * 100).toFixed(2)}%
            </p>
          </div>
          
          <div className="bg-white rounded-lg shadow p-6">
            <h3 className="text-sm font-medium text-gray-500">Daily Rewards</h3>
            <p className="text-2xl font-bold text-blue-600">
              ${portfolioMetrics.dailyRewards.toFixed(2)}
            </p>
          </div>
          
          <div className="bg-white rounded-lg shadow p-6">
            <h3 className="text-sm font-medium text-gray-500">Risk Score</h3>
            <p className={`text-2xl font-bold ${
              portfolioMetrics.riskScore < 4 ? 'text-green-600' :
              portfolioMetrics.riskScore < 7 ? 'text-yellow-600' : 'text-red-600'
            }`}>
              {portfolioMetrics.riskScore.toFixed(1)}/10
            </p>
          </div>
        </div>
        
        <div className="grid grid-cols-1 lg:grid-cols-2 gap-8 mb-8">
          {/* Protocol Distribution */}
          <div className="bg-white rounded-lg shadow p-6">
            <h2 className="text-lg font-semibold mb-4">Protocol Distribution</h2>
            <ResponsiveContainer width="100%" height={300}>
              <PieChart>
                <Pie
                  data={protocolDistribution}
                  cx="50%"
                  cy="50%"
                  outerRadius={80}
                  fill="#8884d8"
                  dataKey="value"
                  label={({ name, percent }) => `${name} ${(percent * 100).toFixed(0)}%`}
                >
                  {protocolDistribution.map((entry, index) => (
                    <Cell key={`cell-${index}`} fill={COLORS[index % COLORS.length]} />
                  ))}
                </Pie>
                <Tooltip formatter={(value: number) => [`$${value.toLocaleString()}`, 'Balance']} />
              </PieChart>
            </ResponsiveContainer>
          </div>
          
          {/* Top Yield Opportunities */}
          <div className="bg-white rounded-lg shadow p-6">
            <h2 className="text-lg font-semibold mb-4">Top Yield Opportunities</h2>
            <div className="space-y-3">
              {opportunities.slice(0, 5).map((opp, index) => (
                <div key={index} className="flex items-center justify-between p-3 border rounded">
                  <div>
                    <p className="font-medium">{opp.protocol}</p>
                    <p className="text-sm text-gray-500">{opp.tokenSymbol}</p>
                  </div>
                  <div className="text-right">
                    <p className="font-semibold text-green-600">
                      {(opp.currentApy * 100).toFixed(2)}% APY
                    </p>
                    <p className="text-xs text-gray-500">
                      Risk: {opp.riskScore.toFixed(1)}/10
                    </p>
                  </div>
                  <button
                    onClick={() => {/* Implement position entry */}}
                    className="ml-4 px-3 py-1 bg-blue-600 text-white rounded text-sm hover:bg-blue-700"
                  >
                    Enter
                  </button>
                </div>
              ))}
            </div>
          </div>
        </div>
        
        {/* Current Positions */}
        <div className="bg-white rounded-lg shadow">
          <div className="px-6 py-4 border-b border-gray-200">
            <h2 className="text-lg font-semibold">Current Positions</h2>
          </div>
          <div className="overflow-x-auto">
            <table className="min-w-full divide-y divide-gray-200">
              <thead className="bg-gray-50">
                <tr>
                  <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
                    Protocol
                  </th>
                  <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
                    Tokens
                  </th>
                  <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
                    Balance
                  </th>
                  <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
                    APY
                  </th>
                  <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
                    Rewards
                  </th>
                  <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
                    Health
                  </th>
                  <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
                    Actions
                  </th>
                </tr>
              </thead>
              <tbody className="bg-white divide-y divide-gray-200">
                {positions.map((position, index) => (
                  <tr key={index}>
                    <td className="px-6 py-4 whitespace-nowrap">
                      <div className="text-sm font-medium text-gray-900">
                        {position.protocol}
                      </div>
                      <div className="text-sm text-gray-500">
                        {position.positionType}
                      </div>
                    </td>
                    <td className="px-6 py-4 whitespace-nowrap">
                      <div className="text-sm text-gray-900">
                        {position.tokenSymbols.join(', ')}
                      </div>
                    </td>
                    <td className="px-6 py-4 whitespace-nowrap">
                      <div className="text-sm font-medium text-gray-900">
                        ${position.balanceUsd.toLocaleString()}
                      </div>
                    </td>
                    <td className="px-6 py-4 whitespace-nowrap">
                      <div className="text-sm font-medium text-green-600">
                        {(position.apy * 100).toFixed(2)}%
                      </div>
                    </td>
                    <td className="px-6 py-4 whitespace-nowrap">
                      <div className="text-sm text-gray-900">
                        ${position.rewardsUsd.toFixed(2)}
                      </div>
                    </td>
                    <td className="px-6 py-4 whitespace-nowrap">
                      {position.healthFactor ? (
                        <div className={`text-sm font-medium ${
                          position.healthFactor > 2 ? 'text-green-600' :
                          position.healthFactor > 1.2 ? 'text-yellow-600' : 'text-red-600'
                        }`}>
                          {position.healthFactor.toFixed(2)}
                        </div>
                      ) : (
                        <span className="text-sm text-gray-400">N/A</span>
                      )}
                    </td>
                    <td className="px-6 py-4 whitespace-nowrap text-sm font-medium">
                      <button className="text-blue-600 hover:text-blue-900 mr-3">
                        Manage
                      </button>
                      <button className="text-red-600 hover:text-red-900">
                        Exit
                      </button>
                    </td>
                  </tr>
                ))}
              </tbody>
            </table>
          </div>
        </div>
      </div>
    </div>
  );
};

export default StablecoinDashboard;

# automated_rebalancer.py
import asyncio
import logging
from typing import Dict, List, Tuple
from web3 import Web3
import time

class ZapperAutomatedRebalancer:
    def __init__(self, zapper_manager: ZapperStablecoinManager, w3: Web3):
        self.zapper = zapper_manager
        self.w3 = w3
        
        # Rebalancing parameters
        self.target_allocations = {
            'lending': 0.4,      # 40% in lending protocols
            'liquidity': 0.3,    # 30% in LP positions
            'vault': 0.25,       # 25% in yield vaults
            'staking': 0.05      # 5% in staking
        }
        
        self.rebalance_threshold = 0.1  # 10% deviation triggers rebalance
        self.min_rebalance_amount = 1000  # $1000 minimum
        self.max_gas_cost_ratio = 0.02   # Max 2% of position in gas costs
        
    async def monitor_and_rebalance(self):
        """Main rebalancing loop"""
        
        while True:
            try:
                # Get current portfolio state
                portfolio = await self.zapper.get_portfolio_overview()
                
                if portfolio['total_balance_usd'] < 10000:  # Skip if portfolio too small
                    await asyncio.sleep(3600)  # Check every hour
                    continue
                
                # Analyze rebalancing needs
                rebalance_actions = await self.analyze_rebalancing_needs(portfolio)
                
                if rebalance_actions:
                    logging.info(f"Found {len(rebalance_actions)} rebalancing opportunities")
                    
                    # Execute rebalancing
                    for action in rebalance_actions:
                        await self.execute_rebalance_action(action)
                        await asyncio.sleep(10)  # Delay between transactions
                
                # Check for yield optimization opportunities
                await self.optimize_yield_positions(portfolio)
                
            except Exception as e:
                logging.error(f"Rebalancing error: {e}")
            
            await asyncio.sleep(3600)  # Run every hour
    
    async def analyze_rebalancing_needs(self, portfolio: Dict) -> List[Dict]:
        """Analyze portfolio and identify rebalancing needs"""
        
        actions = []
        total_balance = portfolio['total_balance_usd']
        
        if total_balance == 0:
            return actions
        
        # Calculate current allocations by category
        current_allocations = {}
        for position in portfolio['stablecoin_positions']:
            category = position.position_type
            if category not in current_allocations:
                current_allocations[category] = 0
            current_allocations[category] += position.balance_usd
        
        # Convert to percentages
        current_percentages = {
            category: balance / total_balance
            for category, balance in current_allocations.items()
        }
        
        # Find positions that need rebalancing
        for category, target_percentage in self.target_allocations.items():
            current_percentage = current_percentages.get(category, 0)
            deviation = abs(current_percentage - target_percentage)
            
            if deviation > self.rebalance_threshold:
                dollar_deviation = deviation * total_balance
                
                if dollar_deviation > self.min_rebalance_amount:
                    if current_percentage > target_percentage:
                        # Need to reduce allocation
                        actions.append({
                            'type': 'reduce',
                            'category': category,
                            'current_percentage': current_percentage,
                            'target_percentage': target_percentage,
                            'amount_to_move': dollar_deviation,
                            'priority': self.calculate_priority(deviation, dollar_deviation)
                        })
                    else:
                        # Need to increase allocation
                        actions.append({
                            'type': 'increase',
                            'category': category,
                            'current_percentage': current_percentage,
                            'target_percentage': target_percentage,
                            'amount_needed': dollar_deviation,
                            'priority': self.calculate_priority(deviation, dollar_deviation)
                        })
        
        # Sort by priority
        actions.sort(key=lambda x: x['priority'], reverse=True)
        
        return actions
    
    def calculate_priority(self, deviation: float, dollar_amount: float) -> float:
        """Calculate rebalancing priority score"""
        
        # Higher deviation and larger amounts get higher priority
        deviation_score = deviation * 100  # Convert to percentage points
        amount_score = min(dollar_amount / 10000, 10)  # Cap at 10 points
        
        return deviation_score + amount_score
    
    async def execute_rebalance_action(self, action: Dict):
        """Execute a specific rebalancing action"""
        
        try:
            if action['type'] == 'reduce':
                await self.reduce_category_allocation(action)
            elif action['type'] == 'increase':
                await self.increase_category_allocation(action)
                
        except Exception as e:
            logging.error(f"Failed to execute rebalance action: {e}")
    
    async def reduce_category_allocation(self, action: Dict):
        """Reduce allocation in over-weighted category"""
        
        category = action['category']
        amount_to_move = action['amount_to_move']
        
        # Get current positions in this category
        portfolio = await self.zapper.get_portfolio_overview()
        category_positions = [
            pos for pos in portfolio['stablecoin_positions']
            if pos.position_type == category
        ]
        
        if not category_positions:
            return
        
        # Sort by lowest APY first (exit worst performers)
        category_positions.sort(key=lambda x: x.apy)
        
        remaining_to_move = amount_to_move
        
        for position in category_positions:
            if remaining_to_move <= 0:
                break
                
            # Calculate how much to exit from this position
            exit_amount = min(remaining_to_move, position.balance_usd * 0.5)  # Max 50% of position
            
            if exit_amount < 100:  # Skip very small amounts
                continue
            
            # Check gas cost efficiency
            estimated_gas = await self.estimate_exit_gas_cost(position)
            if estimated_gas > exit_amount * self.max_gas_cost_ratio:
                continue  # Skip if gas cost too high
            
            # Execute position exit
            success = await self.exit_position_partial(position, exit_amount)
            
            if success:
                remaining_to_move -= exit_amount
                logging.info(f"Exited ${exit_amount:.2f} from {position.protocol}")
    
    async def increase_category_allocation(self, action: Dict):
        """Increase allocation in under-weighted category"""
        
        category = action['category']
        amount_needed = action['amount_needed']
        
        # Find best opportunities in this category
        opportunities = await self.zapper.find_yield_opportunities()
        
        category_opportunities = [
            opp for opp in opportunities
            if self.categorize_opportunity_type(opp) == category
        ]
        
        if not category_opportunities:
            logging.warning(f"No opportunities found for category: {category}")
            return
        
        # Sort by risk-adjusted yield
        category_opportunities.sort(
            key=lambda x: x.current_apy / x.risk_score,
            reverse=True
        )
        
        # Enter best opportunity
        best_opportunity = category_opportunities[0]
        
        # Check gas cost efficiency
        if best_opportunity.entry_gas_cost > amount_needed * self.max_gas_cost_ratio:
            logging.warning(f"Gas cost too high for {best_opportunity.protocol}")
            return
        
        # Execute position entry
        success = await self.enter_position(best_opportunity, amount_needed)
        
        if success:
            logging.info(f"Entered ${amount_needed:.2f} into {best_opportunity.protocol}")
    
    def categorize_opportunity_type(self, opportunity: YieldOpportunity) -> str:
        """Categorize opportunity type based on protocol"""
        
        protocol = opportunity.protocol.lower()
        
        if 'aave' in protocol or 'compound' in protocol:
            return 'lending'
        elif 'uniswap' in protocol or 'curve' in protocol or 'balancer' in protocol:
            return 'liquidity'
        elif 'yearn' in protocol or 'harvest' in protocol:
            return 'vault'
        else:
            return 'other'
    
    async def exit_position_partial(self, position: StablecoinPosition, exit_amount: float) -> bool:
        """Exit partial amount from a position using Zapper"""
        
        try:
            # Use Zapper's zap-out functionality
            url = f"{self.zapper.base_url}/v2/zap-out"
            
            # Calculate percentage to exit
            exit_percentage = exit_amount / position.balance_usd
            
            payload = {
                'poolAddress': position.pool_address,
                'sellTokenAddress': position.token_symbols[0],  # Primary token
                'sellAmount': str(int(exit_amount * 1e6)),  # Convert to token units
                'slippagePercentage': 1,  # 1% slippage
                'gasPrice': await self.get_optimal_gas_price(),
                'userAddress': self.zapper.wallet_address
            }
            
            # Get transaction data from Zapper
            async with self.zapper.session.post(url, json=payload) as response:
                if response.status == 200:
                    tx_data = await response.json()
                    
                    # Execute transaction
                    tx_hash = await self.execute_transaction(tx_data)
                    
                    if tx_hash:
                        logging.info(f"Position exit transaction: {tx_hash}")
                        return True
                        
        except Exception as e:
            logging.error(f"Failed to exit position: {e}")
        
        return False
    
    async def enter_position(self, opportunity: YieldOpportunity, amount: float) -> bool:
        """Enter a new position using Zapper"""
        
        try:
            # Use Zapper's zap-in functionality
            url = f"{self.zapper.base_url}/v2/zap-in"
            
            payload = {
                'poolAddress': opportunity.pool_address,
                'buyTokenAddress': opportunity.token_symbol,
                'buyAmount': str(int(amount * 1e6)),  # Convert to token units
                'slippagePercentage': 1,  # 1% slippage
                'gasPrice': await self.get_optimal_gas_price(),
                'userAddress': self.zapper.wallet_address
            }
            
            # Get transaction data from Zapper
            async with self.zapper.session.post(url, json=payload) as response:
                if response.status == 200:
                    tx_data = await response.json()
                    
                    # Execute transaction
                    tx_hash = await self.execute_transaction(tx_data)
                    
                    if tx_hash:
                        logging.info(f"Position entry transaction: {tx_hash}")
                        return True
                        
        except Exception as e:
            logging.error(f"Failed to enter position: {e}")
        
        return False
    
    async def execute_transaction(self, tx_data: Dict) -> str:
        """Execute a transaction using Web3"""
        
        try:
            # Build transaction
            tx = {
                'to': tx_data['to'],
                'data': tx_data['data'],
                'value': int(tx_data.get('value', '0')),
                'gas': int(tx_data['gas']),
                'gasPrice': int(tx_data['gasPrice']),
                'nonce': self.w3.eth.get_transaction_count(self.zapper.wallet_address)
            }
            
            # Sign transaction
            signed_tx = self.w3.eth.account.sign_transaction(tx, private_key=PRIVATE_KEY)
            
            # Send transaction
            tx_hash = self.w3.eth.send_raw_transaction(signed_tx.rawTransaction)
            
            # Wait for confirmation
            receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)
            
            if receipt['status'] == 1:
                return tx_hash.hex()
            else:
                logging.error(f"Transaction failed: {tx_hash.hex()}")
                return None
                
        except Exception as e:
            logging.error(f"Transaction execution failed: {e}")
            return None
    
    async def get_optimal_gas_price(self) -> int:
        """Get optimal gas price for transactions"""
        
        try:
            # Use EIP-1559 gas pricing if available
            latest_block = self.w3.eth.get_block('latest')
            if 'baseFeePerGas' in latest_block:
                base_fee = latest_block['baseFeePerGas']
                priority_fee = self.w3.eth.max_priority_fee
                return base_fee + priority_fee
            else:
                # Fallback to legacy gas pricing
                return self.w3.eth.gas_price
                
        except Exception:
            # Fallback to current gas price
            return self.w3.eth.gas_price