bitpanda-api 0.1.0

Rust client for Bitpanda API
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

use std::str::FromStr;

use crate::ApiError;

/// Transaction status
#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, Deserialize)]
pub enum TransactionStatus {
    Canceled,
    Finished,
    OpenInvitation,
    Pending,
    Processing,
    Unconfirmed,
    UnconfirmedTransactionOut,
}

impl ToString for TransactionStatus {
    fn to_string(&self) -> String {
        match self {
            TransactionStatus::Canceled => "canceled",
            TransactionStatus::Finished => "finished",
            TransactionStatus::OpenInvitation => "open_invitation",
            TransactionStatus::Pending => "pending",
            TransactionStatus::Processing => "processing",
            TransactionStatus::Unconfirmed => "unconfirmed",
            TransactionStatus::UnconfirmedTransactionOut => "unconfirmed_transaction_out",
        }
        .to_string()
    }
}

impl FromStr for TransactionStatus {
    type Err = ApiError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "canceled" => Ok(Self::Canceled),
            "finished" => Ok(Self::Finished),
            "open_invitation" => Ok(Self::OpenInvitation),
            "pending" => Ok(Self::Pending),
            "processing" => Ok(Self::Processing),
            "unconfirmed" => Ok(Self::Unconfirmed),
            "unconfirmed_transaction_out" => Ok(Self::UnconfirmedTransactionOut),
            _ => Err(ApiError::UnexpectedValue(s.to_string())),
        }
    }
}

/// Transaction type
#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, Deserialize)]
pub enum TransactionType {
    Buy,
    Deposit,
    Ico,
    Refund,
    Sell,
    Transfer,
    Withdrawal,
}

impl FromStr for TransactionType {
    type Err = ApiError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "buy" => Ok(Self::Buy),
            "deposit" => Ok(Self::Deposit),
            "ico" => Ok(Self::Ico),
            "refund" => Ok(Self::Refund),
            "sell" => Ok(Self::Sell),
            "transfer" => Ok(Self::Transfer),
            "withdrawal" => Ok(Self::Withdrawal),
            _ => Err(ApiError::UnexpectedValue(s.to_string())),
        }
    }
}

impl ToString for TransactionType {
    fn to_string(&self) -> String {
        match self {
            TransactionType::Buy => "buy",
            TransactionType::Sell => "sell",
            TransactionType::Deposit => "deposit",
            TransactionType::Ico => "ico",
            TransactionType::Refund => "ico",
            TransactionType::Transfer => "transfer",
            TransactionType::Withdrawal => "withdrawal",
        }
        .to_string()
    }
}

/// Transaction "direction"
#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, Deserialize)]
pub enum InOrOut {
    Incoming,
    Outgoing,
}

impl FromStr for InOrOut {
    type Err = ApiError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "incoming" => Ok(Self::Incoming),
            "outgoing" => Ok(Self::Outgoing),
            _ => Err(ApiError::UnexpectedValue(s.to_string())),
        }
    }
}