Ocean Protocol Data Farming: Turn Environmental Data Into Passive Income Streams

# Install Ocean Protocol Python library
pip install ocean-lib

# Import required modules
from ocean_lib.ocean.ocean import Ocean
from ocean_lib.web3_internal.utils import connect_to_network
from ocean_lib.models.data_token import DataToken
import os

# Configure Ocean Protocol network
config = {
    'network': 'polygon',  # or 'mainnet' for Ethereum
    'provider_url': 'https://polygon-rpc.com',
    'private_key': os.getenv('PRIVATE_KEY')
}

# Initialize Ocean instance
ocean = Ocean(config)
print(f"Connected to {config['network']} network")

# Create data asset for environmental monitoring
def create_environmental_data_pool():
    # Define metadata for environmental dataset
    metadata = {
        "name": "Urban Air Quality Sensors",
        "description": "Hourly PM2.5, NO2, and O3 measurements from 50 city sensors",
        "tags": ["environment", "air-quality", "urban", "pollution"],
        "license": "CC-BY-4.0",
        "price": "10"  # Price in OCEAN tokens
    }
    
    # Create data asset
    data_asset = ocean.assets.create(
        metadata=metadata,
        publisher_wallet=ocean.wallet,
        credentials={"allow": [], "deny": []}
    )
    
    print(f"Created data asset: {data_asset.did}")
    return data_asset

# Add OCEAN tokens to data pool for farming rewards
def add_liquidity_to_pool(data_asset, ocean_amount):
    # Get data token associated with asset
    data_token = ocean.get_data_token(data_asset.did)
    
    # Add liquidity to automated market maker pool
    pool_tx = ocean.pool.create(
        data_token=data_token.address,
        data_token_amount=100,  # Data tokens to add
        OCEAN_amount=ocean_amount,  # OCEAN tokens to stake
        from_wallet=ocean.wallet
    )
    
    print(f"Added liquidity: {ocean_amount} OCEAN tokens")
    print(f"Transaction hash: {pool_tx.transactionHash.hex()}")
    
    return pool_tx

# Track data farming earnings
def check_farming_rewards(pool_address):
    # Get pool statistics
    pool_info = ocean.pool.get_pool_info(pool_address)
    
    # Calculate current rewards
    rewards = ocean.pool.get_rewards(
        pool_address=pool_address,
        wallet_address=ocean.wallet.address
    )
    
    print(f"Total Value Locked: {pool_info['totalLiquidity']} OCEAN")
    print(f"Your Liquidity Share: {pool_info['userLiquidity']} OCEAN")
    print(f"Pending Rewards: {rewards['pending']} OCEAN")
    print(f"Claimed Rewards: {rewards['claimed']} OCEAN")
    
    return rewards

# Lock OCEAN tokens for maximum rewards
def stake_veocean(amount, lock_duration):
    """
    Lock OCEAN tokens to earn veOCEAN and boost rewards
    
    Args:
        amount: OCEAN tokens to lock
        lock_duration: Time in weeks (max 208 weeks)
    """
    
    # Calculate veOCEAN multiplier
    multiplier = lock_duration / 208  # Maximum 4-year lock
    ve_ocean_amount = amount * multiplier
    
    # Execute veOCEAN staking
    stake_tx = ocean.ve_ocean.create_lock(
        amount=amount,
        unlock_time=lock_duration,
        from_wallet=ocean.wallet
    )
    
    print(f"Staked {amount} OCEAN for {lock_duration} weeks")
    print(f"Received {ve_ocean_amount} veOCEAN voting power")
    
    return stake_tx

# Analyze pool performance metrics
def evaluate_pool_performance(pool_address):
    # Get 30-day trading volume
    volume_data = ocean.pool.get_volume_history(
        pool_address=pool_address,
        days=30
    )
    
    # Calculate key metrics
    total_volume = sum(volume_data['daily_volume'])
    avg_daily_volume = total_volume / 30
    liquidity = ocean.pool.get_liquidity(pool_address)
    
    # Volume-to-liquidity ratio
    vol_liquidity_ratio = total_volume / liquidity if liquidity > 0 else 0
    
    metrics = {
        'total_volume': total_volume,
        'avg_daily_volume': avg_daily_volume,
        'liquidity': liquidity,
        'vol_liquidity_ratio': vol_liquidity_ratio
    }
    
    print(f"Pool Performance Metrics:")
    print(f"30-day Volume: {metrics['total_volume']} OCEAN")
    print(f"Daily Avg Volume: {metrics['avg_daily_volume']} OCEAN")
    print(f"Current Liquidity: {metrics['liquidity']} OCEAN")
    print(f"Volume/Liquidity Ratio: {metrics['vol_liquidity_ratio']:.2f}")
    
    return metrics

# Integrate IoT environmental sensors
import json
import time
from datetime import datetime

def collect_environmental_data():
    """
    Simulate environmental sensor data collection
    Replace with actual sensor API calls
    """
    
    # Simulate sensor readings
    sensor_data = {
        'timestamp': datetime.now().isoformat(),
        'location': {'lat': 40.7128, 'lon': -74.0060},
        'measurements': {
            'temperature': 23.5,  # Celsius
            'humidity': 65.2,     # Percentage
            'pm25': 12.3,         # μg/m³
            'no2': 18.7,          # ppb
            'o3': 45.2            # ppb
        },
        'sensor_id': 'NYC_SENSOR_001',
        'quality_score': 0.98
    }
    
    return sensor_data

# Publish sensor data to Ocean Protocol
def publish_sensor_data(data_asset, sensor_data):
    # Store data in IPFS or decentralized storage
    data_url = ocean.assets.upload_data(
        data=json.dumps(sensor_data),
        asset=data_asset
    )
    
    # Update asset metadata with new data
    updated_metadata = data_asset.metadata
    updated_metadata['files'][0]['url'] = data_url
    updated_metadata['updated'] = datetime.now().isoformat()
    
    # Publish update
    ocean.assets.update(
        asset=data_asset,
        metadata=updated_metadata,
        publisher_wallet=ocean.wallet
    )
    
    print(f"Published sensor data: {data_url}")
    return data_url

# Automated environmental data pipeline
import schedule
import threading

class EnvironmentalDataFarm:
    def __init__(self, data_asset, sensors):
        self.data_asset = data_asset
        self.sensors = sensors
        self.running = False
    
    def collect_and_publish(self):
        """Collect from all sensors and publish to Ocean Protocol"""
        try:
            # Collect data from all sensors
            batch_data = []
            for sensor in self.sensors:
                data = collect_environmental_data()  # Replace with actual sensor API
                batch_data.append(data)
            
            # Aggregate and publish
            aggregated_data = self.aggregate_sensor_data(batch_data)
            self.publish_sensor_data(self.data_asset, aggregated_data)
            
            print(f"Published data from {len(self.sensors)} sensors")
            
        except Exception as e:
            print(f"Error in data collection: {e}")
    
    def start_farming(self, interval_hours=1):
        """Start automated data farming"""
        self.running = True
        
        # Schedule data collection every hour
        schedule.every(interval_hours).hours.do(self.collect_and_publish)
        
        # Run scheduler in separate thread
        def run_scheduler():
            while self.running:
                schedule.run_pending()
                time.sleep(60)
        
        scheduler_thread = threading.Thread(target=run_scheduler)
        scheduler_thread.start()
        
        print(f"Started data farming with {interval_hours}h intervals")
    
    def stop_farming(self):
        """Stop automated data collection"""
        self.running = False
        print("Stopped data farming")

# Diversified farming strategy
def create_diversified_portfolio(total_ocean_amount):
    """
    Distribute OCEAN tokens across high-performing pools
    """
    
    # Define allocation strategy
    allocations = {
        'weather_data': 0.30,     # 30% to weather datasets
        'air_quality': 0.25,      # 25% to pollution monitoring
        'biodiversity': 0.20,     # 20% to species tracking
        'climate_models': 0.15,   # 15% to predictive models
        'satellite_data': 0.10    # 10% to remote sensing
    }
    
    portfolio_pools = []
    
    for category, allocation in allocations.items():
        amount = total_ocean_amount * allocation
        
        # Find best pool in category
        best_pool = find_best_pool_by_category(category)
        
        # Add liquidity to selected pool
        tx = add_liquidity_to_pool(best_pool, amount)
        
        portfolio_pools.append({
            'category': category,
            'pool': best_pool,
            'amount': amount,
            'transaction': tx
        })
    
    return portfolio_pools

# Automated portfolio rebalancing
def rebalance_farming_portfolio(portfolio_pools, threshold=0.1):
    """
    Rebalance liquidity based on pool performance
    
    Args:
        portfolio_pools: List of current pool positions
        threshold: Performance difference threshold for rebalancing
    """
    
    # Evaluate current pool performance
    pool_performance = []
    for pool_info in portfolio_pools:
        metrics = evaluate_pool_performance(pool_info['pool'].address)
        pool_performance.append({
            'pool': pool_info,
            'performance': metrics['vol_liquidity_ratio']
        })
    
    # Sort by performance
    pool_performance.sort(key=lambda x: x['performance'], reverse=True)
    
    # Identify underperforming pools
    best_performance = pool_performance[0]['performance']
    rebalance_needed = []
    
    for pool_data in pool_performance:
        performance_diff = (best_performance - pool_data['performance']) / best_performance
        
        if performance_diff > threshold:
            rebalance_needed.append(pool_data)
    
    # Execute rebalancing
    for pool_data in rebalance_needed:
        print(f"Rebalancing underperforming pool: {pool_data['pool']['category']}")
        
        # Remove liquidity from underperforming pool
        remove_tx = ocean.pool.remove_liquidity(
            pool_address=pool_data['pool']['pool'].address,
            amount=pool_data['pool']['amount'],
            from_wallet=ocean.wallet
        )
        
        # Add to best performing pool
        best_pool = pool_performance[0]['pool']['pool']
        add_tx = add_liquidity_to_pool(best_pool, pool_data['pool']['amount'])
        
        print(f"Moved {pool_data['pool']['amount']} OCEAN to better performing pool")
    
    return rebalance_needed

# Data quality validation
def validate_environmental_data(sensor_data):
    """
    Validate environmental sensor data quality
    """
    
    quality_checks = {
        'timestamp_valid': False,
        'coordinates_valid': False,
        'measurements_complete': False,
        'values_in_range': False,
        'sensor_calibrated': False
    }
    
    # Check timestamp format
    try:
        datetime.fromisoformat(sensor_data['timestamp'])
        quality_checks['timestamp_valid'] = True
    except ValueError:
        pass
    
    # Validate GPS coordinates
    lat = sensor_data['location']['lat']
    lon = sensor_data['location']['lon']
    if -90 <= lat <= 90 and -180 <= lon <= 180:
        quality_checks['coordinates_valid'] = True
    
    # Check measurement completeness
    required_measurements = ['temperature', 'humidity', 'pm25']
    has_all_measurements = all(
        measurement in sensor_data['measurements'] 
        for measurement in required_measurements
    )
    quality_checks['measurements_complete'] = has_all_measurements
    
    # Validate measurement ranges
    measurements = sensor_data['measurements']
    ranges_valid = (
        -50 <= measurements.get('temperature', 0) <= 60 and  # Celsius
        0 <= measurements.get('humidity', 0) <= 100 and      # Percentage
        0 <= measurements.get('pm25', 0) <= 500              # μg/m³
    )
    quality_checks['values_in_range'] = ranges_valid
    
    # Check sensor calibration status
    quality_checks['sensor_calibrated'] = sensor_data.get('quality_score', 0) > 0.8
    
    # Calculate overall quality score
    quality_score = sum(quality_checks.values()) / len(quality_checks)
    
    return quality_score, quality_checks

# Farming analytics dashboard
class DataFarmingAnalytics:
    def __init__(self, ocean_instance, wallet_address):
        self.ocean = ocean_instance
        self.wallet = wallet_address
    
    def get_farming_summary(self):
        """Generate comprehensive farming performance report"""
        
        # Get all user's liquidity positions
        positions = self.ocean.pool.get_user_positions(self.wallet)
        
        summary = {
            'total_staked': 0,
            'total_rewards': 0,
            'active_pools': len(positions),
            'best_performing_pool': None,
            'monthly_apr': 0
        }
        
        pool_performance = []
        
        for position in positions:
            # Get pool details
            pool_info = self.ocean.pool.get_pool_info(position['pool_address'])
            
            # Calculate rewards for this pool
            rewards = self.ocean.pool.get_rewards(
                position['pool_address'], 
                self.wallet
            )
            
            pool_data = {
                'pool_address': position['pool_address'],
                'staked_amount': position['liquidity'],
                'rewards_earned': rewards['total'],
                'apr': self.calculate_pool_apr(position['pool_address'])
            }
            
            pool_performance.append(pool_data)
            summary['total_staked'] += pool_data['staked_amount']
            summary['total_rewards'] += pool_data['rewards_earned']
        
        # Find best performing pool
        if pool_performance:
            summary['best_performing_pool'] = max(
                pool_performance, 
                key=lambda x: x['apr']
            )
            summary['monthly_apr'] = sum(p['apr'] for p in pool_performance) / len(pool_performance)
        
        return summary, pool_performance
    
    def calculate_pool_apr(self, pool_address):
        """Calculate annualized percentage return for a pool"""
        
        # Get 30-day reward history
        rewards_history = self.ocean.pool.get_reward_history(
            pool_address, 
            days=30
        )
        
        if not rewards_history:
            return 0
        
        # Calculate daily average rewards
        daily_rewards = sum(rewards_history) / 30
        annual_rewards = daily_rewards * 365
        
        # Get current stake amount
        position = self.ocean.pool.get_user_position(pool_address, self.wallet)
        staked_amount = position['liquidity']
        
        if staked_amount == 0:
            return 0
        
        apr = (annual_rewards / staked_amount) * 100
        return apr