dexpaprika-cli 0.2.0

DexPaprika CLI — free DEX data from the terminal. Pools, tokens, on-chain trades across 33+ chains.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

use anyhow::Result;
use serde::{Deserialize, Serialize};

use crate::client::ApiClient;
use crate::output::OutputFormat;

#[derive(Debug, Deserialize, Serialize)]
pub struct Network {
    pub id: String,
    pub display_name: Option<String>,
    pub volume_usd_24h: Option<f64>,
    pub txns_24h: Option<i64>,
    pub pools_count: Option<i64>,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct DexesResponse {
    pub dexes: Vec<Dex>,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct Dex {
    pub dex_id: Option<String>,
    pub dex_name: Option<String>,
    pub chain: Option<String>,
    pub protocol: Option<String>,
    pub volume_usd_24h: Option<f64>,
    pub txns_24h: Option<i64>,
    pub pools_count: Option<i64>,
}

pub async fn execute_networks(client: &ApiClient, output: OutputFormat, raw: bool) -> Result<()> {
    let networks: Vec<Network> = client.dexpaprika_get("/networks", &[]).await?;
    match output {
        OutputFormat::Table => crate::output::networks::print_networks_table(&networks),
        OutputFormat::Json => {
            crate::output::print_json_wrapped(
                &networks,
                crate::output::ResponseMeta::dexpaprika("/networks"),
                raw,
            )?;
        }
    }
    Ok(())
}

pub async fn execute_dexes(
    client: &ApiClient,
    network: &str,
    limit: usize,
    page: usize,
    output: OutputFormat,
    raw: bool,
) -> Result<()> {
    let limit_str = limit.to_string();
    let page_str = page.to_string();
    let resp: DexesResponse = client
        .dexpaprika_get(
            &format!("/networks/{network}/dexes"),
            &[("limit", &limit_str), ("page", &page_str)],
        )
        .await?;
    let dexes = resp.dexes;
    match output {
        OutputFormat::Table => crate::output::networks::print_dexes_table(&dexes),
        OutputFormat::Json => {
            crate::output::print_json_wrapped(
                &dexes,
                crate::output::ResponseMeta::dexpaprika(&format!("/network/{network}")),
                raw,
            )?;
        }
    }
    Ok(())
}