blokli-client 0.29.1

Client connector to Blokli
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 crate::errors::ErrorKind;

pub mod accounts;
pub mod balances;
pub mod channels;
pub mod graph;
pub mod info;
pub mod safe;
pub mod tickets;
pub mod txs;

#[cynic::schema("blokli")]
pub(crate) mod schema {}

// https://generator.cynic-rs.dev/

#[derive(cynic::Enum, Clone, Copy, Debug, PartialEq, Eq)]
pub enum ChannelStatus {
    #[cynic(rename = "OPEN")]
    Open,
    #[cynic(rename = "PENDINGTOCLOSE")]
    PendingToClose,
    #[cynic(rename = "CLOSED")]
    Closed,
}

#[derive(cynic::Scalar, Debug, Clone, PartialEq, Eq)]
pub struct DateTime(pub String);

#[derive(cynic::Scalar, Debug, Clone, PartialEq, Eq)]
pub struct TokenValueString(pub String);

#[derive(cynic::Scalar, Debug, Clone, PartialEq, Eq)]
#[cynic(graphql_type = "UInt64")]
pub struct Uint64(pub String);

#[derive(cynic::Scalar, Debug, Clone, PartialEq, Eq)]
pub struct Hex32(pub String);

#[derive(cynic::InlineFragments, Debug)]
pub enum CountResult {
    Count(Count),
    MissingFilterError(MissingFilterError),
    QueryFailedError(QueryFailedError),
    #[cynic(fallback)]
    Unknown,
}

impl From<CountResult> for Result<u32, crate::errors::BlokliClientError> {
    fn from(value: CountResult) -> Self {
        match value {
            CountResult::Count(count) => Ok(count.count as u32),
            CountResult::MissingFilterError(e) => Err(e.into()),
            CountResult::QueryFailedError(e) => Err(e.into()),
            CountResult::Unknown => Err(ErrorKind::NoData.into()),
        }
    }
}

#[derive(cynic::QueryFragment, Debug)]
pub struct Count {
    pub __typename: String,
    pub count: i32,
}

#[derive(cynic::QueryFragment, Debug)]
pub struct QueryFailedError {
    pub __typename: String,
    pub message: String,
    pub code: String,
}

impl From<QueryFailedError> for crate::errors::BlokliClientError {
    fn from(value: QueryFailedError) -> Self {
        ErrorKind::BlokliError {
            kind: "query failed",
            code: value.code,
            message: value.message,
        }
        .into()
    }
}

#[derive(cynic::QueryFragment, Debug)]
pub struct MissingFilterError {
    pub __typename: String,
    pub code: String,
    pub message: String,
}

impl From<MissingFilterError> for crate::errors::BlokliClientError {
    fn from(value: MissingFilterError) -> Self {
        ErrorKind::BlokliError {
            kind: "missing filter",
            code: value.code,
            message: value.message,
        }
        .into()
    }
}

#[derive(cynic::QueryFragment, Debug)]
pub struct InvalidAddressError {
    pub __typename: String,
    pub code: String,
    pub message: String,
}

impl From<InvalidAddressError> for crate::errors::BlokliClientError {
    fn from(value: InvalidAddressError) -> Self {
        ErrorKind::BlokliError {
            kind: "invalid address",
            code: value.code,
            message: value.message,
        }
        .into()
    }
}