spume 0.2.0

Lightweight, ergonomic Solana JSON-RPC wasm 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
119
120
121
122
123
124
125
126

use {
    crate::{WasmPubsubClient, pubsub_provider::Subscription},
    serde_json::json,
    solana_address::Address,
    solana_rpc_client_types::{
        config::{
            RpcAccountInfoConfig, RpcBlockSubscribeConfig, RpcBlockSubscribeFilter,
            RpcProgramAccountsConfig, RpcSignatureSubscribeConfig, RpcTransactionLogsConfig,
            RpcTransactionLogsFilter,
        },
        request::RpcError,
        response::{
            Response, RpcBlockUpdate, RpcKeyedAccount, RpcLogsResponse, RpcSignatureResult,
            RpcVote, SlotInfo, SlotUpdate, UiAccount,
        },
    },
};

type SubResult<T> = Result<Subscription<T>, Box<RpcError>>;

impl WasmPubsubClient {
    /// Subscribe to changes of a given account's lamports or data.
    pub async fn account_subscribe(
        &self,
        address: &Address,
        config: Option<RpcAccountInfoConfig>,
    ) -> SubResult<Response<Option<UiAccount>>> {
        self.provider
            .subscribe(
                "accountSubscribe",
                "accountUnsubscribe",
                json!([address.to_string(), config]),
            )
            .await
    }

    /// Subscribe to incoming blocks reaching the configured commitment.
    pub async fn block_subscribe(
        &self,
        filter: RpcBlockSubscribeFilter,
        config: Option<RpcBlockSubscribeConfig>,
    ) -> SubResult<Response<RpcBlockUpdate>> {
        self.provider
            .subscribe(
                "blockSubscribe",
                "blockUnsubscribe",
                json!([filter, config]),
            )
            .await
    }

    /// Subscribe to transaction log messages matching the given filter.
    pub async fn logs_subscribe(
        &self,
        filter: RpcTransactionLogsFilter,
        config: Option<RpcTransactionLogsConfig>,
    ) -> SubResult<Response<RpcLogsResponse>> {
        self.provider
            .subscribe("logsSubscribe", "logsUnsubscribe", json!([filter, config]))
            .await
    }

    /// Subscribe to account changes for accounts owned by the given program.
    pub async fn program_subscribe(
        &self,
        program_id: &Address,
        config: Option<RpcProgramAccountsConfig>,
    ) -> SubResult<Response<RpcKeyedAccount>> {
        self.provider
            .subscribe(
                "programSubscribe",
                "programUnsubscribe",
                json!([program_id.to_string(), config]),
            )
            .await
    }

    /// Subscribe to the validator setting a new root slot.
    pub async fn root_subscribe(&self) -> SubResult<u64> {
        self.provider
            .subscribe("rootSubscribe", "rootUnsubscribe", json!([]))
            .await
    }

    /// Subscribe to status notifications for a single transaction signature.
    ///
    /// The server auto-unsubscribes once the configured commitment is reached.
    pub async fn signature_subscribe(
        &self,
        signature: String,
        config: Option<RpcSignatureSubscribeConfig>,
    ) -> SubResult<Response<RpcSignatureResult>> {
        self.provider
            .subscribe(
                "signatureSubscribe",
                "signatureUnsubscribe",
                json!([signature, config]),
            )
            .await
    }

    /// Subscribe to new slots being processed by the validator.
    pub async fn slot_subscribe(&self) -> SubResult<SlotInfo> {
        self.provider
            .subscribe("slotSubscribe", "slotUnsubscribe", json!([]))
            .await
    }

    /// Subscribe to tagged slot lifecycle updates.
    pub async fn slots_updates_subscribe(&self) -> SubResult<SlotUpdate> {
        self.provider
            .subscribe(
                "slotsUpdatesSubscribe",
                "slotsUpdatesUnsubscribe",
                json!([]),
            )
            .await
    }

    /// Subscribe to gossip vote notifications.
    pub async fn vote_subscribe(&self) -> SubResult<RpcVote> {
        self.provider
            .subscribe("voteSubscribe", "voteUnsubscribe", json!([]))
            .await
    }
}