helius-rust-client 0.1.0

A rust client wrapping Helius APIs and the standard Solana RPC client
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

use reqwest::Client as RestClient;
use solana_client::nonblocking::rpc_client::RpcClient;
use solana_client::rpc_client::Mocks;
use solana_sdk::{commitment_config::CommitmentConfig, genesis_config::ClusterType};
use std::time::Duration;

pub const API_URL_V0: &str = "https://api.helius.xyz/v0";
pub const API_URL_V1: &str = "https://api.helius.xyz/v1";
pub const MAINNET_RPC_URL: &str = "https://rpc.helius.xyz/?api-key=";
pub const DEVNET_RPC_URL: &str = "https://rpc-devnet.helius.xyz/?api-key=";

pub struct HeliusClient {
    pub rpc_client: RpcClient,
    pub http_client: RestClient,
    pub cluster: ClusterType,
    pub(crate) api_key: String,
}

impl HeliusClient {
    pub fn new(api_key: String, cluster_type: ClusterType) -> Self {
        let url = format_url(api_key.clone(), cluster_type);
        HeliusClient {
            rpc_client: RpcClient::new(url),
            cluster: cluster_type,
            api_key,
            http_client: reqwest::Client::new(),
        }
    }

    pub fn new_with_commitment(
        api_key: String,
        cluster_type: ClusterType,
        commitment_config: CommitmentConfig,
    ) -> Self {
        let url = format_url(api_key.clone(), cluster_type);
        HeliusClient {
            rpc_client: RpcClient::new_with_commitment(url, commitment_config),
            cluster: cluster_type,
            api_key,
            http_client: reqwest::Client::new(),
        }
    }

    pub fn new_with_timeout(api_key: String, cluster_type: ClusterType, timeout: Duration) -> Self {
        let url = format_url(api_key.clone(), cluster_type);
        HeliusClient {
            rpc_client: RpcClient::new_with_timeout(url, timeout),
            cluster: cluster_type,
            api_key,
            http_client: reqwest::Client::new(),
        }
    }

    pub fn new_with_timeout_and_commitment(
        api_key: String,
        cluster_type: ClusterType,
        timeout: Duration,
        commitment_config: CommitmentConfig,
    ) -> Self {
        let url = format_url(api_key.clone(), cluster_type);
        HeliusClient {
            rpc_client: RpcClient::new_with_timeout_and_commitment(url, timeout, commitment_config),
            cluster: cluster_type,
            api_key,
            http_client: reqwest::Client::new(),
        }
    }

    pub fn new_with_timeouts_and_commitment(
        api_key: String,
        cluster_type: ClusterType,
        timeout: Duration,
        commitment_config: CommitmentConfig,
        confirm_transaction_initial_timeout: Duration,
    ) -> Self {
        let url = format_url(api_key.clone(), cluster_type);
        HeliusClient {
            rpc_client: RpcClient::new_with_timeouts_and_commitment(
                url,
                timeout,
                commitment_config,
                confirm_transaction_initial_timeout,
            ),
            cluster: cluster_type,
            api_key,
            http_client: reqwest::Client::new(),
        }
    }

    pub fn new_mock(api_key: String, cluster_type: ClusterType) -> Self {
        let url = format_url(api_key.clone(), cluster_type);
        HeliusClient {
            rpc_client: RpcClient::new_mock(url),
            cluster: cluster_type,
            api_key,
            http_client: reqwest::Client::new(),
        }
    }

    pub fn new_mock_with_mocks(api_key: String, cluster_type: ClusterType, mocks: Mocks) -> Self {
        let url = format_url(api_key.clone(), cluster_type);
        HeliusClient {
            rpc_client: RpcClient::new_mock_with_mocks(url, mocks),
            cluster: cluster_type,
            api_key,
            http_client: reqwest::Client::new(),
        }
    }
}

fn format_url(api_key: String, cluster_type: ClusterType) -> String {
    match cluster_type {
        ClusterType::Testnet => panic!("Testnet cluster not supported"),
        ClusterType::MainnetBeta => format!("{}{}", MAINNET_RPC_URL, api_key),
        ClusterType::Devnet => format!("{}{}", DEVNET_RPC_URL, api_key),
        ClusterType::Development => panic!("Local cluster not supported"),
    }
}