DexPaprika Go SDK

package main

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

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

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

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

    // Get Ethereum network details
    networks, err := client.Networks.List(ctx)
    if err != nil {
        log.Fatalf("Error fetching networks: %v", err)
    }

    var ethereum *dexpaprika.Network
    for _, network := range networks {
        if network.ID == "ethereum" {
            ethereum = &network
            break
        }
    }

    if ethereum == nil {
        log.Fatal("Ethereum network not found")
    }

    fmt.Printf("Found %s with %d DEXes\n", ethereum.DisplayName, ethereum.DexesCount)

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

    // Find WETH/USDC pools
    options := &dexpaprika.ListOptions{
        Limit:   5,
        Page:    0,
        OrderBy: "volume_usd",
        Sort:    "desc",
    }
    pools, err := client.Tokens.GetPools(
        ctx,
        "ethereum",
        "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", // WETH
        options,
        "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", // USDC
    )
    if err != nil {
        log.Fatalf("Error fetching pools: %v", err)
    }

    // Show top pools
    fmt.Println("Top WETH/USDC pools:")
    for _, pool := range pools.Pools {
        fmt.Printf("%s: $%.2f 24h volume\n", pool.DexName, pool.VolumeUSD)
    }
}

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",
        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
            }
            fmt.Printf("%s: $%.2f 24h volume\n", pool.DexName, pool.VolumeUSD)
        }
    }

    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
}