quicknode-sdk 0.8.1

Core library for quicknode sdk
Documentation 
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
76
77
78
79
80
81
82
83
84
85
86
87
88

use quicknode_sdk::{admin::GetEndpointsRequest, QuicknodeSdk, SdkFullConfig};

#[tokio::main]
#[allow(clippy::unwrap_used, clippy::expect_used)]
async fn main() {
    let config = SdkFullConfig::from_env().expect("Config from env failed");
    let qn = QuicknodeSdk::new(&config).expect("sdk failed to initialize");

    match qn.admin.account_info().await {
        Ok(resp) => {
            if let Some(a) = &resp.data {
                let plan = a
                    .subscription
                    .as_ref()
                    .and_then(|s| s.plan_name.clone())
                    .unwrap_or_else(|| "<none>".to_string());
                println!(
                    "account {} | {} | billing={:?} | plan={}",
                    a.id, a.name, a.billing_version, plan
                );
            }
        }
        Err(e) => eprintln!("account_info error: {e}"),
    }

    match qn.admin.get_api_credits("ethereum").await {
        Ok(resp) => {
            if let Some(credits) = &resp.data {
                println!("ethereum api credits: {} methods", credits.len());
                for c in credits.iter().take(3) {
                    println!("  {} = {}", c.method, c.credits);
                }
            }
        }
        Err(e) => eprintln!("get_api_credits error: {e}"),
    }

    let params = GetEndpointsRequest::builder()
        .limit(20)
        .sort_by("created_at".to_string())
        .sort_direction("desc".to_string())
        .build();

    let first_endpoint_id = match qn.admin.get_endpoints(&params).await {
        Ok(resp) => {
            if let Some(p) = &resp.pagination {
                println!(
                    "{} of {} (offset {}, limit {})",
                    resp.data.len(),
                    p.total,
                    p.offset,
                    p.limit
                );
            }
            for ep in &resp.data {
                println!(
                    "{} | {} | {} | {} | dedicated={} flat={} multichain={}",
                    ep.id,
                    ep.name,
                    ep.status,
                    ep.chain,
                    ep.is_dedicated,
                    ep.is_flat_rate,
                    ep.is_multichain
                );
            }
            resp.data.first().map(|ep| ep.id.clone())
        }
        Err(e) => {
            eprintln!("get_endpoints error: {e}");
            None
        }
    };

    let Some(endpoint_id) = first_endpoint_id else {
        return;
    };

    match qn.admin.get_rate_limits(&endpoint_id).await {
        Ok(resp) => println!("get_rate_limits: {:?}", resp.data),
        Err(e) => eprintln!("get_rate_limits error: {e}"),
    }

    match qn.admin.get_endpoint_urls(&endpoint_id).await {
        Ok(resp) => println!("get_endpoint_urls: {:?}", resp.data),
        Err(e) => eprintln!("get_endpoint_urls error: {e}"),
    }
}