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

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "github.com/coinpaprika/dexpaprika-sdk-go/dexpaprika"
)

const (
    weth = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
    usdc = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
)

func main() {
    client := dexpaprika.NewClient()

    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    // Networks come back as a slice of Network{ID, DisplayName}
    networks, err := client.Networks.List(ctx)
    if err != nil {
        log.Fatalf("Error fetching networks: %v", err)
    }
    for _, network := range networks {
        if network.ID == "ethereum" {
            fmt.Printf("%s is one of %d networks\n", network.DisplayName, len(networks))
        }
    }

    // Price lives under Summary
    token, err := client.Tokens.GetDetails(ctx, "ethereum", weth)
    if err != nil {
        log.Fatalf("Error fetching token details: %v", err)
    }
    fmt.Printf("%s price: $%.2f\n", token.Name, token.Summary.PriceUSD)

    // Pools for a token are served by pool search. The SDK copies the rows
    // into Pools and fills VolumeUSD from volume_usd_24h. There is no pair
    // filter, so match the second token client-side.
    pools, err := client.Tokens.GetPools(ctx, "ethereum", weth, &dexpaprika.TokenPoolsOptions{
        ListOptions: &dexpaprika.ListOptions{Limit: 20, OrderBy: "volume_usd_24h", Sort: "desc"},
    })
    if err != nil {
        log.Fatalf("Error fetching pools: %v", err)
    }

    fmt.Println("Top WETH/USDC pools:")
    shown := 0
    for _, pool := range pools.Pools {
        for _, t := range pool.Tokens {
            if t.ID == usdc && shown < 5 {
                fmt.Printf("%s: $%.2f 24h volume\n", pool.DexName, pool.VolumeUSD)
                shown++
            }
        }
    }
}

import (
    "context"
    "errors"
    "fmt"
    "log"
    "time"

    "github.com/coinpaprika/dexpaprika-sdk-go/dexpaprika"
)

func handleAPIErrors() {
    client := dexpaprika.NewClient()
    ctx := context.Background()

    // Attempt to get a token with an invalid address
    _, err := client.Tokens.GetDetails(ctx, "ethereum", "0xinvalidaddress")
    if err != nil {
        // Check for specific error types
        var apiErr *dexpaprika.APIError
        if errors.As(err, &apiErr) {
            switch apiErr.StatusCode {
            case 404:
                fmt.Println("Token not found")
            case 429:
                fmt.Println("Rate limit exceeded, retry after a delay")
            case 500:
                fmt.Println("Server error, retry may succeed")
            default:
                fmt.Printf("API error: %s\n", apiErr.Message)
            }
        } else {
            // Handle non-API errors (like network issues)
            fmt.Printf("Non-API error: %v\n", err)
        }

        // Check if error is retryable
        if dexpaprika.IsRetryable(err) {
            fmt.Println("This error is retryable")
        }
    }
}

import (
    "context"
    "fmt"
    "time"

    "github.com/coinpaprika/dexpaprika-sdk-go/dexpaprika"
)

func useCaching() {
    // Create a regular client
    client := dexpaprika.NewClient()

    // Create a cached client with 5-minute TTL
    cachedClient := dexpaprika.NewCachedClient(client, nil, 5*time.Minute)

    // Create context
    ctx := context.Background()

    // First call - hits the API
    startTime := time.Now()
    networks, err := cachedClient.GetNetworks(ctx)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("First call (API): %d networks, took %v\n", len(networks), time.Since(startTime))

    // Second call - served from cache (much faster)
    startTime = time.Now()
    networks, err = cachedClient.GetNetworks(ctx)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("Second call (cached): %d networks, took %v\n", len(networks), time.Since(startTime))
}

import (
    "context"
    "fmt"
    "time"

    "github.com/coinpaprika/dexpaprika-sdk-go/dexpaprika"
)

func usePagination() {
    client := dexpaprika.NewClient()
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    // Create a paginator for Ethereum pools with 50 items per page
    options := &dexpaprika.ListOptions{
        Limit:   50,
        OrderBy: "volume_usd_24h",
        Sort:    "desc",
    }
    paginator := dexpaprika.NewPoolsPaginator(client, options).ForNetwork("ethereum")

    // Count total pools processed
    totalPools := 0

    // Process first 3 pages (or fewer if there aren't that many)
    for i := 0; i < 3 && paginator.HasNextPage(); i++ {
        // Get next page of results
        if err := paginator.GetNextPage(ctx); err != nil {
            fmt.Printf("Error getting page: %v\n", err)
            break
        }

        // Process current page
        pools := paginator.GetCurrentPage()
        totalPools += len(pools)

        // Process first few pools in each page
        fmt.Printf("=== Page %d ===\n", i+1)
        for j, pool := range pools {
            if j >= 3 {
                fmt.Printf("...and %d more pools\n", len(pools)-3)
                break
            }
            var vol float64
            if pool.VolumeUSD24h != nil {
                vol = *pool.VolumeUSD24h
            }
            fmt.Printf("%s: $%.2f 24h volume\n", pool.DexName, vol)
        }
    }

    fmt.Printf("Processed %d pools total\n", totalPools)
}

import (
    "net/http"
    "time"

    "github.com/coinpaprika/dexpaprika-sdk-go/dexpaprika"
)

func configureClient() *dexpaprika.Client {
    // Create a client with custom configuration
    client := dexpaprika.NewClient(
        // Custom HTTP client with longer timeout
        dexpaprika.WithHTTPClient(&http.Client{
            Timeout: 60 * time.Second,
        }),
        
        // Custom retry configuration (5 retries with backoff)
        dexpaprika.WithRetryConfig(5, 2*time.Second, 30*time.Second),
        
        // Rate limiting to 3 requests per second
        dexpaprika.WithRateLimit(3.0),
        
        // Custom user agent
        dexpaprika.WithUserAgent("MyApp/1.0 DexPaprikaClient"),
    )

    return client
}