DexPaprika DEX API PHP SDK — On‑chain Liquidity & Swap Data Client

<?php

require_once __DIR__ . '/vendor/autoload.php';

use DexPaprika\Client;
use DexPaprika\Exception\DexPaprikaApiException;

function main() {
    try {
        // Initialize client
        $client = new Client();
        
        // Get Ethereum network details
        $networks = $client->networks->getNetworks();
        $ethereum = null;
        foreach ($networks['networks'] as $network) {
            if ($network['id'] === 'ethereum') {
                $ethereum = $network;
                break;
            }
        }
        echo "Found {$ethereum['display_name']} with {$ethereum['dexes_count']} DEXes\n";
        
        // Get WETH token details
        $weth = $client->tokens->getTokenDetails(
            'ethereum',
            '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'
        );
        echo "{$weth['name']} price: \${$weth['price_usd']}\n";
        
        // Find WETH/USDC pools
        $pools = $client->tokens->getTokenPools(
            'ethereum',
            '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',  // WETH
            [
                'limit' => 5, 
                'orderBy' => 'volume_usd',
                'sort' => 'desc',
                'address' => '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'  // USDC
            ]
        );
        
        // Show top pools
        echo "Top WETH/USDC pools:\n";
        foreach ($pools['pools'] as $pool) {
            echo "{$pool['dex_name']}: $" . number_format($pool['volume_usd'], 2) . " 24h volume\n";
        }
    } catch (DexPaprikaApiException $e) {
        echo "API Error: {$e->getMessage()}\n";
    } catch (Exception $e) {
        echo "Error: {$e->getMessage()}\n";
    }
}

main();

<?php

require_once __DIR__ . '/vendor/autoload.php';

use DexPaprika\Client;
use DexPaprika\Exception\DexPaprikaApiException;
use DexPaprika\Exception\NotFoundException;
use DexPaprika\Exception\RateLimitException;
use DexPaprika\Exception\ServerException;
use DexPaprika\Exception\NetworkException;

// Basic error handling
try {
    $client = new Client();
    $token = $client->tokens->getTokenDetails('ethereum', '0xinvalidaddress');
} catch (NotFoundException $e) {
    echo "Token not found: {$e->getMessage()}\n";
} catch (RateLimitException $e) {
    echo "Rate limit exceeded. Try again in: {$e->getRetryAfter()} seconds\n";
} catch (ServerException $e) {
    echo "Server error occurred: {$e->getMessage()}\n";
} catch (NetworkException $e) {
    echo "Network error: {$e->getMessage()}\n";
} catch (DexPaprikaApiException $e) {
    echo "API error: {$e->getMessage()} (Code: {$e->getCode()})\n";
} catch (Exception $e) {
    echo "General error: {$e->getMessage()}\n";
}

// The SDK automatically retries on these status codes:
// 408 (Request Timeout), 429 (Too Many Requests),
// 500, 502, 503, 504 (Server Errors)

// Custom retry configuration
use DexPaprika\Config;

$config = new Config();
$config->setMaxRetries(4);  // Number of retry attempts (default: 3)
$config->setRetryDelays([100, 500, 1000, 5000]);  // Delay in milliseconds

$client = new Client(null, null, false, $config);

// All API requests will now use these retry settings
try {
    $networks = $client->networks->getNetworks();
} catch (Exception $e) {
    echo "Failed after multiple retries: {$e->getMessage()}\n";
}

<?php

require_once __DIR__ . '/vendor/autoload.php';

use DexPaprika\Client;
use DexPaprika\Cache\FilesystemCache;

// The SDK includes built-in caching capabilities
// Demonstration of cache behavior

// Create a client with default cache (1 hour TTL)
$client = new Client();
$client->setupCache();

// First call - hits the API
$startTime = microtime(true);
$networks = $client->networks->getNetworks();
$firstCallTime = microtime(true) - $startTime;
echo "First call (API): {$networks['networks']} networks, took {$firstCallTime} s\n";

// Second call - served from cache (much faster)
$startTime = microtime(true);
$networks = $client->networks->getNetworks();
$secondCallTime = microtime(true) - $startTime;
echo "Second call (cached): {$networks['networks']} networks, took {$secondCallTime} s\n";
echo "Cache speedup: {$firstCallTime / $secondCallTime} x\n";

// You can skip the cache when you need fresh data
$client->getConfig()->setCacheEnabled(false);
$freshNetworks = $client->networks->getNetworks();
$client->getConfig()->setCacheEnabled(true);

// Custom cache configuration
$cache = new FilesystemCache('/path/to/custom/cache');
$client->setupCache($cache, 300);  // 5 minutes TTL

// Clear the entire cache
$client->getConfig()->getCache()->clear();

<?php

require_once __DIR__ . '/vendor/autoload.php';

use DexPaprika\Client;

function fetchAllPools($networkId) {
    $client = new Client();
    $allPools = [];
    $page = 0;
    $limit = 50;
    $hasMore = true;
    
    while ($hasMore) {
        $response = $client->pools->getNetworkPools(
            $networkId, 
            [
                'page' => $page, 
                'limit' => $limit, 
                'sort' => 'desc', 
                'orderBy' => 'volume_usd'
            ]
        );
        
        $allPools = array_merge($allPools, $response['pools']);
        
        // Check if there are more pages
        $hasMore = count($response['pools']) == $limit;
        $page++;
        
        // Adding a small delay to avoid hitting rate limits
        usleep(100000);  // 100ms
    }
    
    echo "Fetched a total of {$allPools} pools on {$networkId}\n";
    return $allPools;
}

// Alternative approach using built-in paginator
function fetchAllPoolsWithPaginator($networkId) {
    $client = new Client();
    $allPools = [];
    
    // Create a paginator for network pools
    $paginator = $client->createPaginator(
        $client->pools,
        'getNetworkPools',
        [
            $networkId,
            [
                'limit' => 50,
                'orderBy' => 'volume_usd',
                'sort' => 'desc'
            ]
        ]
    );
    
    // Iterate through all pages (or up to a maximum)
    $paginator->setMaxPages(10);  // Optional: limit to 10 pages
    foreach ($paginator as $page => $response) {
        $allPools = array_merge($allPools, $response['pools']);
        echo "Processed page {$page}, got {$response['pools']} pools\n";
    }
    
    echo "Fetched a total of {$allPools} pools on {$networkId}\n";
    return $allPools;
}

// Usage example
$ethereumPools = fetchAllPools('ethereum');
// or
$ethereumPools = fetchAllPoolsWithPaginator('ethereum');

<?php

require_once __DIR__ . '/vendor/autoload.php';

use DexPaprika\Client;
use DexPaprika\Config;

// Create a client that returns objects instead of arrays
$config = new Config();
$config->setResponseFormat('object');
$client = new Client(null, null, true, $config);

// Get pool details
$pool = $client->pools->getPoolDetails(
    'ethereum',
    '0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640'  // USDC/WETH Uniswap v3 pool
);

// Access pool properties as object properties
echo "Pool: {$pool->tokens[0]->symbol}/{$pool->tokens[1]->symbol}\n";
echo "Volume (24h): \${$pool->day->volume_usd}\n";
echo "Transactions (24h): {$pool->day->txns}\n";
echo "Price: \${$pool->last_price_usd}\n";

// Time interval data is available for multiple timeframes
echo "1h price change: {$pool->hour1->last_price_usd_change}%\n";
echo "24h price change: {$pool->day->last_price_usd_change}%\n";

// Combining with array-based response for specific API calls
$client->getConfig()->setResponseFormat('array');
$networks = $client->networks->getNetworks();

// Back to object mode
$client->getConfig()->setResponseFormat('object');
$token = $client->tokens->getTokenDetails('ethereum', '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2');
echo "{$token->name} price: \${$token->price_usd}\n";