Skip to main content

Liquidity Monitoring

Learn how to monitor liquidity pools in real-time, identify imbalanced pools, and track liquidity health across the Hoops Finance ecosystem. This guide shows you how to build tools for liquidity analysis and pool monitoring.

Overview​

This page covers:

  • Getting real-time pool reserves and liquidity data
  • Identifying imbalanced or highly active pools
  • Monitoring liquidity changes over time
  • Building liquidity health dashboards
  • Detecting arbitrage opportunities

Pool Reserves and Liquidity​

Get Pool Reserves​

import requests
import json

def get_pair_liquidity(pair_contract):
    """Fetch liquidity data for a specific pair"""
    url = f"https://api.hoops.finance/pairs/{pair_contract}/liquidity"
    response = requests.get(url)
    response.raise_for_status()
    return response.json()

def get_pair_details(pair_contract):
    """Fetch detailed pair information including reserves"""
    url = f"https://api.hoops.finance/pairs/{pair_contract}"
    response = requests.get(url)
    response.raise_for_status()
    return response.json()

# Usage
pair_address = "CAB6MICC2WKRT372U3FRPKGGVB5R3FDJSMWJL5XK6R3XWMJUCA4RJMXU"

# Get liquidity data
liquidity_data = get_pair_liquidity(pair_address)
pair_details = get_pair_details(pair_address)

print(f"Pair: {pair_details['token0Symbol']}/{pair_details['token1Symbol']}")
print(f"Token0 Reserves: {pair_details['reserve0']}")
print(f"Token1 Reserves: {pair_details['reserve1']}")
print(f"Total Supply: {pair_details['totalSupply']}")
print(f"Current Price: {pair_details['token0Price']} {pair_details['token0Symbol']} per {pair_details['token1Symbol']}")
Use Case

Great for: Real-time trading interfaces, price feeds, and liquidity monitoring dashboards

Response Fields Explained​

FieldDescriptionExample
reserve0Token0 reserves in pool1000000000000000000000
reserve1Token1 reserves in pool500000000000000000000
totalSupplyTotal LP token supply707106781186547524
token0PriceCurrent price of token0 in token10.5
token1PriceCurrent price of token1 in token02.0
tvlTotal Value Locked in USD1500000.00

Identifying Imbalanced Pools​

Pool Balance Analysis​

def analyze_pool_balance(pair_contract):
    """Analyze pool balance and identify potential issues"""
    pair_details = get_pair_details(pair_contract)
    
    # Calculate balance ratio
    reserve0 = float(pair_details['reserve0'])
    reserve1 = float(pair_details['reserve1'])
    
    if reserve0 == 0 or reserve1 == 0:
        return {
            'status': 'empty_pool',
            'message': 'Pool has zero reserves'
        }
    
    # Calculate balance ratio (should be close to 1 for balanced pools)
    balance_ratio = reserve0 / reserve1
    price_ratio = float(pair_details['token0Price'])
    
    # Determine if pool is imbalanced
    imbalance_threshold = 0.1  # 10% threshold
    is_imbalanced = abs(balance_ratio - price_ratio) / price_ratio > imbalance_threshold
    
    return {
        'pair': f"{pair_details['token0Symbol']}/{pair_details['token1Symbol']}",
        'reserve0': reserve0,
        'reserve1': reserve1,
        'balance_ratio': balance_ratio,
        'price_ratio': price_ratio,
        'is_imbalanced': is_imbalanced,
        'imbalance_percentage': abs(balance_ratio - price_ratio) / price_ratio * 100,
        'tvl': float(pair_details['tvl']),
        'volume24h': float(pair_details['volume24h'])
    }

def find_imbalanced_pools(threshold=0.1):
    """Find all imbalanced pools above threshold"""
    all_pairs = requests.get("https://api.hoops.finance/pairs").json()
    imbalanced_pools = []
    
    for pair in all_pairs['pairs']:
        analysis = analyze_pool_balance(pair['pairContract'])
        if analysis.get('is_imbalanced', False):
            imbalanced_pools.append(analysis)
    
    # Sort by imbalance percentage
    imbalanced_pools.sort(key=lambda x: x['imbalance_percentage'], reverse=True)
    return imbalanced_pools

# Usage
pair_address = "CAB6MICC2WKRT372U3FRPKGGVB5R3FDJSMWJL5XK6R3XWMJUCA4RJMXU"
analysis = analyze_pool_balance(pair_address)

print(f"Pool: {analysis['pair']}")
print(f"Balance Ratio: {analysis['balance_ratio']:.4f}")
print(f"Price Ratio: {analysis['price_ratio']:.4f}")
print(f"Imbalance: {analysis['imbalance_percentage']:.2f}%")
print(f"Is Imbalanced: {analysis['is_imbalanced']}")
print(f"TVL: ${analysis['tvl']:,.2f}")
print(f"24h Volume: ${analysis['volume24h']:,.2f}")

# Find all imbalanced pools
print("\n=== MOST IMBALANCED POOLS ===")
imbalanced = find_imbalanced_pools(threshold=0.05)  # 5% threshold
for pool in imbalanced[:5]:
    print(f"{pool['pair']}: {pool['imbalance_percentage']:.2f}% imbalance")
async function analyzePoolBalance(pairContract) {
    try {
        const pairDetails = await getPairDetails(pairContract);
        
        // Calculate balance ratio
        const reserve0 = parseFloat(pairDetails.reserve0);
        const reserve1 = parseFloat(pairDetails.reserve1);
        
        if (reserve0 === 0 || reserve1 === 0) {
            return {
                status: 'empty_pool',
                message: 'Pool has zero reserves'
            };
        }
        
        // Calculate balance ratio
        const balanceRatio = reserve0 / reserve1;
        const priceRatio = parseFloat(pairDetails.token0Price);
        
        // Determine if pool is imbalanced
        const imbalanceThreshold = 0.1; // 10% threshold
        const isImbalanced = Math.abs(balanceRatio - priceRatio) / priceRatio > imbalanceThreshold;
        
        return {
            pair: `${pairDetails.token0Symbol}/${pairDetails.token1Symbol}`,
            reserve0: reserve0,
            reserve1: reserve1,
            balanceRatio: balanceRatio,
            priceRatio: priceRatio,
            isImbalanced: isImbalanced,
            imbalancePercentage: Math.abs(balanceRatio - priceRatio) / priceRatio * 100,
            tvl: parseFloat(pairDetails.tvl),
            volume24h: parseFloat(pairDetails.volume24h)
        };
    } catch (error) {
        console.error('Error analyzing pool balance:', error.message);
        throw error;
    }
}

async function findImbalancedPools(threshold = 0.1) {
    try {
        const response = await fetch('https://api.hoops.finance/pairs');
        
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        
        const allPairs = await response.json();
        const imbalancedPools = [];
        
        for (const pair of allPairs.pairs) {
            try {
                const analysis = await analyzePoolBalance(pair.pairContract);
                if (analysis.isImbalanced) {
                    imbalancedPools.push(analysis);
                }
            } catch (error) {
                console.warn(`Error analyzing pair ${pair.pairContract}:`, error.message);
            }
        }
        
        // Sort by imbalance percentage
        imbalancedPools.sort((a, b) => b.imbalancePercentage - a.imbalancePercentage);
        return imbalancedPools;
    } catch (error) {
        console.error('Error finding imbalanced pools:', error.message);
        throw error;
    }
}

// Usage
const pairAddress = "CAB6MICC2WKRT372U3FRPKGGVB5R3FDJSMWJL5XK6R3XWMJUCA4RJMXU";

analyzePoolBalance(pairAddress).then(analysis => {
    console.log(`Pool: ${analysis.pair}`);
    console.log(`Balance Ratio: ${analysis.balanceRatio.toFixed(4)}`);
    console.log(`Price Ratio: ${analysis.priceRatio.toFixed(4)}`);
    console.log(`Imbalance: ${analysis.imbalancePercentage.toFixed(2)}%`);
    console.log(`Is Imbalanced: ${analysis.isImbalanced}`);
    console.log(`TVL: $${analysis.tvl.toLocaleString()}`);
    console.log(`24h Volume: $${analysis.volume24h.toLocaleString()}`);
});

// Find all imbalanced pools
findImbalancedPools(0.05).then(imbalanced => {
    console.log('\n=== MOST IMBALANCED POOLS ===');
    imbalanced.slice(0, 5).forEach(pool => {
        console.log(`${pool.pair}: ${pool.imbalancePercentage.toFixed(2)}% imbalance`);
    });
});
Use Case

Great for: Arbitrage detection, rebalancing tools, and risk assessment

High Activity Pool Detection​

Identify Active Pools​

def find_high_activity_pools(volume_threshold=10000, tvl_threshold=100000):
    """Find pools with high trading activity"""
    all_pairs = requests.get("https://api.hoops.finance/pairs").json()
    active_pools = []
    
    for pair in all_pairs['pairs']:
        volume24h = float(pair.get('volume24h', 0))
        tvl = float(pair.get('tvl', 0))
        
        if volume24h >= volume_threshold and tvl >= tvl_threshold:
            active_pools.append({
                'pair': f"{pair['token0Symbol']}/{pair['token1Symbol']}",
                'pairContract': pair['pairContract'],
                'volume24h': volume24h,
                'tvl': tvl,
                'volume_tvl_ratio': volume24h / tvl if tvl > 0 else 0,
                'fee': pair.get('fee', 0)
            })
    
    # Sort by volume/TVL ratio (activity indicator)
    active_pools.sort(key=lambda x: x['volume_tvl_ratio'], reverse=True)
    return active_pools

def get_pool_health_metrics(pair_contract):
    """Get comprehensive health metrics for a pool"""
    pair_details = get_pair_details(pair_contract)
    
    # Calculate various health indicators
    tvl = float(pair_details['tvl'])
    volume24h = float(pair_details['volume24h'])
    reserve0 = float(pair_details['reserve0'])
    reserve1 = float(pair_details['reserve1'])
    
    # Health metrics
    volume_tvl_ratio = volume24h / tvl if tvl > 0 else 0
    liquidity_depth = min(reserve0, reserve1)  # Minimum reserve
    price_impact = 1 / liquidity_depth if liquidity_depth > 0 else float('inf')
    
    return {
        'pair': f"{pair_details['token0Symbol']}/{pair_details['token1Symbol']}",
        'tvl': tvl,
        'volume24h': volume24h,
        'volume_tvl_ratio': volume_tvl_ratio,
        'liquidity_depth': liquidity_depth,
        'price_impact': price_impact,
        'fee': pair_details.get('fee', 0),
        'health_score': calculate_health_score(tvl, volume24h, liquidity_depth)
    }

def calculate_health_score(tvl, volume24h, liquidity_depth):
    """Calculate a simple health score (0-100)"""
    # Normalize values (these thresholds can be adjusted)
    tvl_score = min(tvl / 1000000, 1) * 40  # Max 40 points for TVL
    volume_score = min(volume24h / 100000, 1) * 30  # Max 30 points for volume
    liquidity_score = min(liquidity_depth / 100000, 1) * 30  # Max 30 points for liquidity
    
    return tvl_score + volume_score + liquidity_score

# Usage
print("=== HIGH ACTIVITY POOLS ===")
active_pools = find_high_activity_pools(volume_threshold=5000, tvl_threshold=50000)
for pool in active_pools[:10]:
    print(f"{pool['pair']}: ${pool['volume24h']:,.0f} volume, "
          f"${pool['tvl']:,.0f} TVL, "
          f"{pool['volume_tvl_ratio']:.2f} ratio")

print("\n=== POOL HEALTH ANALYSIS ===")
pair_address = "CAB6MICC2WKRT372U3FRPKGGVB5R3FDJSMWJL5XK6R3XWMJUCA4RJMXU"
health = get_pool_health_metrics(pair_address)
print(f"Pool: {health['pair']}")
print(f"Health Score: {health['health_score']:.1f}/100")
print(f"Volume/TVL Ratio: {health['volume_tvl_ratio']:.2f}")
print(f"Liquidity Depth: {health['liquidity_depth']:,.0f}")
print(f"Price Impact: {health['price_impact']:.6f}")
async function findHighActivityPools(volumeThreshold = 10000, tvlThreshold = 100000) {
    try {
        const response = await fetch('https://api.hoops.finance/pairs');
        
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        
        const allPairs = await response.json();
        const activePools = [];
        
        allPairs.pairs.forEach(pair => {
            const volume24h = parseFloat(pair.volume24h || 0);
            const tvl = parseFloat(pair.tvl || 0);
            
            if (volume24h >= volumeThreshold && tvl >= tvlThreshold) {
                activePools.push({
                    pair: `${pair.token0Symbol}/${pair.token1Symbol}`,
                    pairContract: pair.pairContract,
                    volume24h: volume24h,
                    tvl: tvl,
                    volumeTvlRatio: volume24h / tvl,
                    fee: pair.fee || 0
                });
            }
        });
        
        // Sort by volume/TVL ratio
        activePools.sort((a, b) => b.volumeTvlRatio - a.volumeTvlRatio);
        return activePools;
    } catch (error) {
        console.error('Error finding high activity pools:', error.message);
        throw error;
    }
}

async function getPoolHealthMetrics(pairContract) {
    try {
        const pairDetails = await getPairDetails(pairContract);
        
        const tvl = parseFloat(pairDetails.tvl);
        const volume24h = parseFloat(pairDetails.volume24h);
        const reserve0 = parseFloat(pairDetails.reserve0);
        const reserve1 = parseFloat(pairDetails.reserve1);
        
        const volumeTvlRatio = volume24h / tvl;
        const liquidityDepth = Math.min(reserve0, reserve1);
        const priceImpact = 1 / liquidityDepth;
        
        return {
            pair: `${pairDetails.token0Symbol}/${pairDetails.token1Symbol}`,
            tvl: tvl,
            volume24h: volume24h,
            volumeTvlRatio: volumeTvlRatio,
            liquidityDepth: liquidityDepth,
            priceImpact: priceImpact,
            fee: pairDetails.fee || 0,
            healthScore: calculateHealthScore(tvl, volume24h, liquidityDepth)
        };
    } catch (error) {
        console.error('Error getting pool health metrics:', error.message);
        throw error;
    }
}

function calculateHealthScore(tvl, volume24h, liquidityDepth) {
    const tvlScore = Math.min(tvl / 1000000, 1) * 40;
    const volumeScore = Math.min(volume24h / 100000, 1) * 30;
    const liquidityScore = Math.min(liquidityDepth / 100000, 1) * 30;
    
    return tvlScore + volumeScore + liquidityScore;
}

// Usage
console.log('=== HIGH ACTIVITY POOLS ===');
findHighActivityPools(5000, 50000).then(activePools => {
    activePools.slice(0, 10).forEach(pool => {
        console.log(`${pool.pair}: $${pool.volume24h.toLocaleString()} volume, $${pool.tvl.toLocaleString()} TVL, ${pool.volumeTvlRatio.toFixed(2)} ratio`);
    });
});

console.log('\n=== POOL HEALTH ANALYSIS ===');
const pairAddress = "CAB6MICC2WKRT372U3FRPKGGVB5R3FDJSMWJL5XK6R3XWMJUCA4RJMXU";
getPoolHealthMetrics(pairAddress).then(health => {
    console.log(`Pool: ${health.pair}`);
    console.log(`Health Score: ${health.healthScore.toFixed(1)}/100`);
    console.log(`Volume/TVL Ratio: ${health.volumeTvlRatio.toFixed(2)}`);
    console.log(`Liquidity Depth: ${health.liquidityDepth.toLocaleString()}`);
    console.log(`Price Impact: ${health.priceImpact.toFixed(6)}`);
});
Use Case

Great for: Trading strategy development, risk management, and portfolio optimization

Building a Liquidity Dashboard​

Complete Liquidity Monitoring System​

import requests
import time
from datetime import datetime
import json

class LiquidityMonitor:
    def __init__(self):
        self.base_url = "https://api.hoops.finance"
        self.monitored_pools = []
    
    def add_pool_to_monitor(self, pair_contract, name=None):
        """Add a pool to monitoring list"""
        if name is None:
            pair_details = get_pair_details(pair_contract)
            name = f"{pair_details['token0Symbol']}/{pair_details['token1Symbol']}"
        
        self.monitored_pools.append({
            'contract': pair_contract,
            'name': name,
            'last_check': None,
            'history': []
        })
    
    def get_pool_snapshot(self, pair_contract):
        """Get current snapshot of pool state"""
        pair_details = get_pair_details(pair_contract)
        
        return {
            'timestamp': datetime.now().isoformat(),
            'reserve0': float(pair_details['reserve0']),
            'reserve1': float(pair_details['reserve1']),
            'tvl': float(pair_details['tvl']),
            'volume24h': float(pair_details['volume24h']),
            'price': float(pair_details['token0Price']),
            'fee': pair_details.get('fee', 0)
        }
    
    def monitor_pools(self, interval=60):
        """Monitor all pools at specified interval (seconds)"""
        print(f"Starting liquidity monitoring for {len(self.monitored_pools)} pools...")
        print(f"Update interval: {interval} seconds")
        
        try:
            while True:
                for pool in self.monitored_pools:
                    try:
                        snapshot = self.get_pool_snapshot(pool['contract'])
                        pool['history'].append(snapshot)
                        pool['last_check'] = datetime.now()
                        
                        # Keep only last 100 snapshots
                        if len(pool['history']) > 100:
                            pool['history'] = pool['history'][-100:]
                        
                        # Check for significant changes
                        self.check_for_alerts(pool, snapshot)
                        
                    except Exception as e:
                        print(f"Error monitoring {pool['name']}: {e}")
                
                time.sleep(interval)
                
        except KeyboardInterrupt:
            print("\nMonitoring stopped by user")
    
    def check_for_alerts(self, pool, snapshot):
        """Check for significant changes and alert"""
        if len(pool['history']) < 2:
            return
        
        previous = pool['history'][-2]
        
        # Calculate changes
        tvl_change = (snapshot['tvl'] - previous['tvl']) / previous['tvl'] * 100
        price_change = (snapshot['price'] - previous['price']) / previous['price'] * 100
        
        # Alert thresholds
        if abs(tvl_change) > 5:  # 5% TVL change
            print(f"ALERT: {pool['name']} TVL changed by {tvl_change:.2f}%")
        
        if abs(price_change) > 2:  # 2% price change
            print(f"ALERT: {pool['name']} price changed by {price_change:.2f}%")
    
    def generate_report(self):
        """Generate monitoring report"""
        print("\n=== LIQUIDITY MONITORING REPORT ===")
        print(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        print(f"Monitored Pools: {len(self.monitored_pools)}")
        
        for pool in self.monitored_pools:
            if pool['history']:
                latest = pool['history'][-1]
                print(f"\n{pool['name']}:")
                print(f"  Current TVL: ${latest['tvl']:,.2f}")
                print(f"  24h Volume: ${latest['volume24h']:,.2f}")
                print(f"  Current Price: {latest['price']:.6f}")
                print(f"  Last Update: {pool['last_check']}")
    
    def save_history(self, filename='liquidity_history.json'):
        """Save monitoring history to file"""
        data = {
            'timestamp': datetime.now().isoformat(),
            'pools': self.monitored_pools
        }
        
        with open(filename, 'w') as f:
            json.dump(data, f, indent=2)
        
        print(f"History saved to {filename}")

# Usage
monitor = LiquidityMonitor()

# Add pools to monitor
monitor.add_pool_to_monitor("CAB6MICC2WKRT372U3FRPKGGVB5R3FDJSMWJL5XK6R3XWMJUCA4RJMXU")
monitor.add_pool_to_monitor("CAB6MICC2WKRT372U3FRPKGGVB5R3FDJSMWJL5XK6R3XWMJUCA4RJMXU")

# Generate initial report
monitor.generate_report()

# Start monitoring (uncomment to run)
# monitor.monitor_pools(interval=30)  # Check every 30 seconds
class LiquidityMonitor {
    constructor() {
        this.baseUrl = 'https://api.hoops.finance';
        this.monitoredPools = [];
    }
    
    addPoolToMonitor(pairContract, name = null) {
        return getPairDetails(pairContract).then(pairDetails => {
            const poolName = name || `${pairDetails.token0Symbol}/${pairDetails.token1Symbol}`;
            
            this.monitoredPools.push({
                contract: pairContract,
                name: poolName,
                lastCheck: null,
                history: []
            });
            
            console.log(`Added ${poolName} to monitoring`);
        });
    }
    
    async getPoolSnapshot(pairContract) {
        const pairDetails = await getPairDetails(pairContract);
        
        return {
            timestamp: new Date().toISOString(),
            reserve0: parseFloat(pairDetails.reserve0),
            reserve1: parseFloat(pairDetails.reserve1),
            tvl: parseFloat(pairDetails.tvl),
            volume24h: parseFloat(pairDetails.volume24h),
            price: parseFloat(pairDetails.token0Price),
            fee: pairDetails.fee || 0
        };
    }
    
    async monitorPools(interval = 60000) { // Default 1 minute
        console.log(`Starting liquidity monitoring for ${this.monitoredPools.length} pools...`);
        console.log(`Update interval: ${interval / 1000} seconds`);
        
        const monitorInterval = setInterval(async () => {
            for (const pool of this.monitoredPools) {
                try {
                    const snapshot = await this.getPoolSnapshot(pool.contract);
                    pool.history.push(snapshot);
                    pool.lastCheck = new Date();
                    
                    // Keep only last 100 snapshots
                    if (pool.history.length > 100) {
                        pool.history = pool.history.slice(-100);
                    }
                    
                    // Check for alerts
                    this.checkForAlerts(pool, snapshot);
                    
                } catch (error) {
                    console.error(`Error monitoring ${pool.name}:`, error.message);
                }
            }
        }, interval);
        
        return monitorInterval;
    }
    
    checkForAlerts(pool, snapshot) {
        if (pool.history.length < 2) return;
        
        const previous = pool.history[pool.history.length - 2];
        
        // Calculate changes
        const tvlChange = (snapshot.tvl - previous.tvl) / previous.tvl * 100;
        const priceChange = (snapshot.price - previous.price) / previous.price * 100;
        
        // Alert thresholds
        if (Math.abs(tvlChange) > 5) {
            console.log(`ALERT: ${pool.name} TVL changed by ${tvlChange.toFixed(2)}%`);
        }
        
        if (Math.abs(priceChange) > 2) {
            console.log(`ALERT: ${pool.name} price changed by ${priceChange.toFixed(2)}%`);
        }
    }
    
    generateReport() {
        console.log('\n=== LIQUIDITY MONITORING REPORT ===');
        console.log(`Generated: ${new Date().toLocaleString()}`);
        console.log(`Monitored Pools: ${this.monitoredPools.length}`);
        
        this.monitoredPools.forEach(pool => {
            if (pool.history.length > 0) {
                const latest = pool.history[pool.history.length - 1];
                console.log(`\n${pool.name}:`);
                console.log(`  Current TVL: $${latest.tvl.toLocaleString()}`);
                console.log(`  24h Volume: $${latest.volume24h.toLocaleString()}`);
                console.log(`  Current Price: ${latest.price.toFixed(6)}`);
                console.log(`  Last Update: ${pool.lastCheck}`);
            }
        });
    }
    
    saveHistory(filename = 'liquidity_history.json') {
        const data = {
            timestamp: new Date().toISOString(),
            pools: this.monitoredPools
        };
        
        // In Node.js, you'd use fs.writeFileSync
        console.log(`History would be saved to ${filename}`);
        console.log('Data:', JSON.stringify(data, null, 2));
    }
}

// Usage
const monitor = new LiquidityMonitor();

// Add pools to monitor
monitor.addPoolToMonitor("CAB6MICC2WKRT372U3FRPKGGVB5R3FDJSMWJL5XK6R3XWMJUCA4RJMXU");

// Generate initial report
setTimeout(() => {
    monitor.generateReport();
}, 1000);

// Start monitoring (uncomment to run)
// monitor.monitorPools(30000); // Check every 30 seconds

Arbitrage Opportunity Detection​

Simple Arbitrage Scanner​

def scan_for_arbitrage_opportunities():
    """Scan all pools for potential arbitrage opportunities"""
    all_pairs = requests.get("https://api.hoops.finance/pairs").json()
    opportunities = []
    
    # Group pairs by token combinations
    token_pairs = {}
    for pair in all_pairs['pairs']:
        token0 = pair['token0Symbol']
        token1 = pair['token1Symbol']
        
        # Create sorted key for consistent grouping
        key = tuple(sorted([token0, token1]))
        if key not in token_pairs:
            token_pairs[key] = []
        token_pairs[key].append(pair)
    
    # Check for price differences in same token pairs
    for token_combo, pairs in token_pairs.items():
        if len(pairs) > 1:
            prices = []
            for pair in pairs:
                price = float(pair['token0Price'])
                prices.append({
                    'pair': f"{pair['token0Symbol']}/{pair['token1Symbol']}",
                    'price': price,
                    'tvl': float(pair['tvl']),
                    'volume24h': float(pair['volume24h']),
                    'contract': pair['pairContract']
                })
            
            # Find min and max prices
            min_price = min(prices, key=lambda x: x['price'])
            max_price = max(prices, key=lambda x: x['price'])
            
            # Calculate spread
            spread = (max_price['price'] - min_price['price']) / min_price['price'] * 100
            
            if spread > 1:  # 1% minimum spread
                opportunities.append({
                    'tokens': token_combo,
                    'spread': spread,
                    'min_price': min_price,
                    'max_price': max_price,
                    'pairs': prices
                })
    
    # Sort by spread
    opportunities.sort(key=lambda x: x['spread'], reverse=True)
    return opportunities

# Usage
print("=== ARBITRAGE OPPORTUNITIES ===")
opportunities = scan_for_arbitrage_opportunities()

for opp in opportunities[:5]:
    print(f"\n{opp['tokens'][0]}/{opp['tokens'][1]} - {opp['spread']:.2f}% spread")
    print(f"  Min: {opp['min_price']['pair']} @ {opp['min_price']['price']:.6f}")
    print(f"  Max: {opp['max_price']['pair']} @ {opp['max_price']['price']:.6f}")
    print(f"  Min TVL: ${opp['min_price']['tvl']:,.0f}")
    print(f"  Max TVL: ${opp['max_price']['tvl']:,.0f}")

Next Steps​

Rate Limiting

Remember to implement proper rate limiting in production applications. The API allows 120 requests per minute.

Monitoring Best Practices
  • Use appropriate intervals for monitoring (30-60 seconds for real-time, 5-15 minutes for trends)
  • Implement alert thresholds based on your use case
  • Store historical data for trend analysis
  • Consider using WebSocket connections for real-time updates when available