DexPaprika DEX API TypeScript SDK: on-chain liquidity and swap data client

import { DexPaprikaClient } from 'dexpaprika-sdk';

const WETH = '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2';
const USDC = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48';

async function main() {
  const client = new DexPaprikaClient();

  // Networks come back as a plain array of { id, display_name }
  const networks = await client.networks.list();
  const ethereum = networks.find(n => n.id === 'ethereum');
  console.log(`${ethereum.display_name} is one of ${networks.length} networks`);

  // Price lives under summary
  const weth = await client.tokens.getDetails('ethereum', WETH);
  console.log(`${weth.name} price: $${weth.summary.price_usd.toFixed(2)}`);

  // Pools for a token are served by pool search. Rows sit under results,
  // sorted by volume_usd_24h. There is no pair filter, so match the second
  // token client-side.
  const pools = await client.tokens.getPools('ethereum', WETH, {
    limit: 20,
    orderBy: 'volume_usd_24h',
    sort: 'desc',
  });
  const wethUsdc = pools.results.filter(p => p.tokens.some(t => t.id === USDC));

  console.log('Top WETH/USDC pools:');
  for (const pool of wethUsdc.slice(0, 5)) {
    console.log(`${pool.dex_name}: $${pool.volume_usd_24h.toLocaleString('en-US', { maximumFractionDigits: 2 })} 24h volume`);
  }
}

main().catch(console.error);

import {
  DexPaprikaClient,
  ApiError,
  NetworkNotFoundError,
  PoolNotFoundError,
} from 'dexpaprika-sdk';

// Basic error handling
try {
  const client = new DexPaprikaClient();
  const token = await client.tokens.getDetails('ethereum', '0xinvalidaddress');
} catch (error) {
  // Every SDK error has a readable message that includes the HTTP status
  console.error('Error:', error.message);

  // Or branch on the error class
  if (error instanceof NetworkNotFoundError || error instanceof PoolNotFoundError) {
    console.error('Unknown network or pool');
  } else if (error instanceof ApiError && error.statusCode === 404) {
    console.error('Resource not found');
  } else if (error instanceof ApiError && error.statusCode === 429) {
    console.error('Rate limit exceeded');
  }
}

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

// Custom retry configuration
const client = new DexPaprikaClient('https://api.dexpaprika.com', {}, {
  retry: {
    maxRetries: 3,
    delaySequenceMs: [200, 500, 1000],
    retryableStatuses: [429, 500, 503]
  }
});

import { DexPaprikaClient, Cache } from 'dexpaprika-sdk';

// The SDK includes built-in caching by default
// This example shows how to configure it

// Configure caching with custom settings
const client = new DexPaprikaClient('https://api.dexpaprika.com', {}, {
  cache: {
    ttl: 60 * 1000, // 1 minute cache TTL (default is 5 minutes)
    maxSize: 100,   // Store up to 100 responses (default is 1000)
    enabled: true   // Enable caching (enabled by default)
  }
});

// Demonstration of cache behavior
async function demonstrateCaching() {
  console.time('First call');
  await client.networks.list(); // Makes an API request
  console.timeEnd('First call');
  
  console.time('Second call');
  await client.networks.list(); // Returns cached result
  console.timeEnd('Second call');
  
  // You can also manage the cache manually
  client.clearCache();                // Clear all cached data
  console.log(client.cacheSize);      // Get current cache size
  client.setCacheEnabled(false);      // Disable caching
}

// Using the Cache class directly
const manualCache = new Cache({ 
  ttl: 30 * 1000,  // 30 second TTL
  maxSize: 50      // Store maximum 50 items
});

manualCache.set('myKey', { data: 'example data' });
const data = manualCache.get('myKey');
manualCache.delete('myKey');
manualCache.clear();

import { DexPaprikaClient } from 'dexpaprika-sdk';

async function fetchAllPools(networkId, maxPages = 10) {
  const client = new DexPaprikaClient();
  const allPools = [];
  const limit = 50;
  let cursor;

  // Every page is one request against your allowance, so cap the walk
  for (let page = 0; page < maxPages; page++) {
    const response = await client.pools.listByNetwork(
      networkId,
      {
        limit,
        sort: 'desc',
        orderBy: 'volume_usd_24h',
        cursor
      }
    );

    allPools.push(...response.results);

    // The search endpoint is cursor-paginated, not page-numbered
    if (!response.has_next_page || !response.next_cursor) break;
    cursor = response.next_cursor;

    // Pause between pages to stay under your per-minute limit:
    // https://docs.dexpaprika.com/knowledge-base/rate-limits
    await new Promise(resolve => setTimeout(resolve, 4000));
  }

  console.log(`Fetched a total of ${allPools.length} pools on ${networkId}`);
  return allPools;
}

// Usage example
fetchAllPools('ethereum').catch(console.error);

import { DexPaprikaClient } from 'dexpaprika-sdk';

// Create client with custom configuration
const client = new DexPaprikaClient(
  'https://api.dexpaprika.com', // Base URL (optional)
  {                             // axios request config (optional)
    timeout: 60000,             // 60 second timeout
    headers: {
      'User-Agent': 'MyApp/1.0 DexPaprikaSDK'
    }
  },
  {
    // Retry configuration (optional)
    retry: {
      maxRetries: 5,
      delaySequenceMs: [100, 500, 1000, 2000, 5000],
      retryableStatuses: [429, 500, 502, 503, 504]
    },
    
    // Cache configuration (optional)
    cache: {
      ttl: 10 * 60 * 1000, // 10 minutes TTL
      maxSize: 500,        // Store up to 500 responses
      enabled: true        // Enable caching
    }
  }
);

// Usage example
async function fetchWithCustomClient() {
  try {
    const networks = await client.networks.list();
    console.log(`Fetched ${networks.length} networks with custom client`);
  } catch (err) {
    console.error('Error:', err);
  }
}