quicknode-sdk 0.6.0

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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use std::{thread, time::Duration};

use quicknode_sdk::{
    webhooks::{
        ActivateWebhookParams, CreateWebhookFromTemplateParams, EvmContractEventsTemplate,
        EvmWalletFilterTemplate, GetWebhooksParams, TemplateArgs, UpdateWebhookParams,
        WebhookDestinationAttributes, WebhookStartFrom,
    },
    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");

    let before = qn
        .webhooks
        .list_webhooks(&GetWebhooksParams::default())
        .await
        .expect("list_webhooks failed");
    println!(
        "webhooks before: {} (total={})",
        before.data.len(),
        before.page_info.total
    );

    let count = qn
        .webhooks
        .get_enabled_count()
        .await
        .expect("get_enabled_count failed");
    println!("enabled count: {}", count.total);

    let template_args = TemplateArgs::EvmWalletFilter(EvmWalletFilterTemplate {
        wallets: vec!["0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48".to_string()],
    });

    let create_params = CreateWebhookFromTemplateParams {
        name: "E2E Test Webhook".to_string(),
        network: "ethereum-mainnet".to_string(),
        notification_email: None,
        destination_attributes: WebhookDestinationAttributes {
            url: "https://webhook.site/ae19071a-2dcc-4035-9cdf-406dcb4719ef".to_string(),
            security_token: None,
            compression: "none".to_string(),
        },
        template_args,
    };
    let webhook = qn
        .webhooks
        .create_webhook_from_template(&create_params)
        .await
        .expect("create_webhook_from_template failed");
    let id = webhook.id.clone();
    println!("created: {} | {}", id, webhook.status);
    thread::sleep(Duration::from_secs(1));

    let fetched = qn
        .webhooks
        .get_webhook(&id)
        .await
        .expect("get_webhook failed");
    println!("fetched: {} | {}", fetched.id, fetched.name);

    let update_params = UpdateWebhookParams {
        name: Some("E2E Test Webhook Updated".to_string()),
        ..Default::default()
    };
    let updated = qn
        .webhooks
        .update_webhook(&id, &update_params)
        .await
        .expect("update_webhook failed");
    println!("updated name: {}", updated.name);
    thread::sleep(Duration::from_secs(1));

    qn.webhooks
        .pause_webhook(&id)
        .await
        .expect("pause_webhook failed");
    println!("paused");

    let activate_params = ActivateWebhookParams {
        start_from: WebhookStartFrom::Latest,
    };
    qn.webhooks
        .activate_webhook(&id, &activate_params)
        .await
        .expect("activate_webhook failed");
    println!("activated");

    qn.webhooks
        .delete_webhook(&id)
        .await
        .expect("delete_webhook failed");
    println!("deleted: {id}");
    thread::sleep(Duration::from_secs(1));

    // Exercise the evm-contract-events template, which carries the multi-word
    // `event_hashes` field. The API expects `eventHashes` on the wire.
    let contract_events_args = TemplateArgs::EvmContractEvents(EvmContractEventsTemplate {
        contracts: vec!["0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48".to_string()],
        event_hashes: vec![
            "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef".to_string(),
        ],
    });
    let contract_events_params = CreateWebhookFromTemplateParams {
        name: "E2E Test Webhook (evmContractEvents)".to_string(),
        network: "ethereum-mainnet".to_string(),
        notification_email: None,
        destination_attributes: WebhookDestinationAttributes {
            url: "https://webhook.site/ae19071a-2dcc-4035-9cdf-406dcb4719ef".to_string(),
            security_token: None,
            compression: "none".to_string(),
        },
        template_args: contract_events_args,
    };
    let ce_webhook = qn
        .webhooks
        .create_webhook_from_template(&contract_events_params)
        .await
        .expect("create_webhook_from_template (evmContractEvents) failed");
    println!(
        "created (evmContractEvents): {} | {}",
        ce_webhook.id, ce_webhook.status
    );
    thread::sleep(Duration::from_secs(1));
    qn.webhooks
        .delete_webhook(&ce_webhook.id)
        .await
        .expect("delete_webhook (evmContractEvents) failed");
    println!("deleted (evmContractEvents): {}", ce_webhook.id);
    thread::sleep(Duration::from_secs(1));

    let after = qn
        .webhooks
        .list_webhooks(&GetWebhooksParams::default())
        .await
        .expect("list_webhooks failed");
    println!(
        "webhooks after: {} (total={})",
        after.data.len(),
        after.page_info.total
    );
}