waves_rust/model/account/
balance.rs

1use serde_json::Value;
2
3use crate::error::{Error, Result};
4use crate::model::account::Address;
5use crate::util::JsonDeserializer;
6
7#[derive(Eq, PartialEq, Clone, Debug)]
8pub struct Balance {
9    address: Address,
10    balance: u64,
11}
12
13impl Balance {
14    pub fn new(address: Address, balance: u64) -> Balance {
15        Balance { address, balance }
16    }
17
18    pub fn address(&self) -> Address {
19        self.address.clone()
20    }
21
22    pub fn balance(&self) -> u64 {
23        self.balance
24    }
25}
26
27impl TryFrom<&Value> for Balance {
28    type Error = Error;
29
30    fn try_from(value: &Value) -> Result<Self> {
31        let address =
32            Address::from_string(&JsonDeserializer::safe_to_string_from_field(value, "id")?)?;
33        let balance = JsonDeserializer::safe_to_int_from_field(value, "balance")?;
34        Ok(Balance::new(address, balance as u64))
35    }
36}
37
38#[derive(Eq, PartialEq, Clone, Debug)]
39pub struct BalanceDetails {
40    address: Address,
41    available: u64,
42    regular: u64,
43    generating: u64,
44    effective: u64,
45}
46
47impl BalanceDetails {
48    pub fn new(
49        address: Address,
50        available: u64,
51        regular: u64,
52        generating: u64,
53        effective: u64,
54    ) -> BalanceDetails {
55        BalanceDetails {
56            address,
57            available,
58            regular,
59            generating,
60            effective,
61        }
62    }
63
64    pub fn address(&self) -> Address {
65        self.address.clone()
66    }
67
68    pub fn available(&self) -> u64 {
69        self.available
70    }
71
72    pub fn regular(&self) -> u64 {
73        self.regular
74    }
75
76    pub fn generating(&self) -> u64 {
77        self.generating
78    }
79
80    pub fn effective(&self) -> u64 {
81        self.effective
82    }
83}
84
85impl TryFrom<&Value> for BalanceDetails {
86    type Error = Error;
87
88    fn try_from(value: &Value) -> Result<Self> {
89        let address = Address::from_string(&JsonDeserializer::safe_to_string_from_field(
90            value, "address",
91        )?)?;
92        let available = JsonDeserializer::safe_to_int_from_field(value, "available")? as u64;
93        let regular = JsonDeserializer::safe_to_int_from_field(value, "regular")? as u64;
94        let generating = JsonDeserializer::safe_to_int_from_field(value, "generating")? as u64;
95        let effective = JsonDeserializer::safe_to_int_from_field(value, "effective")? as u64;
96        Ok(BalanceDetails::new(
97            address, available, regular, generating, effective,
98        ))
99    }
100}
101
102#[cfg(test)]
103mod tests {
104
105    use std::fs;
106
107    use crate::error::Result;
108    use crate::model::{Address, Balance, BalanceDetails, ByteString};
109    use serde_json::{json, Value};
110
111    #[test]
112    fn test_balance_details_from_json() -> Result<()> {
113        let data = fs::read_to_string("./tests/resources/addresses/balance_details_rs.json")
114            .expect("Unable to read file");
115        let json: &Value = &serde_json::from_str(&data).expect("failed to generate json from str");
116        let balance_details: BalanceDetails = json.try_into()?;
117        assert_eq!(
118            "3PAETTtuW7aSiyKtn9GuML3RgtV1xdq1mQW",
119            balance_details.address().encoded()
120        );
121        assert_eq!(139400001, balance_details.regular());
122        assert_eq!(139400002, balance_details.generating());
123        assert_eq!(139400003, balance_details.available());
124        assert_eq!(139400004, balance_details.effective());
125        Ok(())
126    }
127
128    #[test]
129    fn test_create_struct_balance_details() -> Result<()> {
130        let balance_details: BalanceDetails = BalanceDetails::new(
131            Address::from_string("3PAETTtuW7aSiyKtn9GuML3RgtV1xdq1mQW")?,
132            139400003,
133            139400001,
134            139400002,
135            139400004,
136        );
137        assert_eq!(
138            "3PAETTtuW7aSiyKtn9GuML3RgtV1xdq1mQW",
139            balance_details.address().encoded()
140        );
141        assert_eq!(139400001, balance_details.regular());
142        assert_eq!(139400002, balance_details.generating());
143        assert_eq!(139400003, balance_details.available());
144        assert_eq!(139400004, balance_details.effective());
145        Ok(())
146    }
147
148    #[test]
149    fn test_balance_from_json() -> Result<()> {
150        let json: &Value = &json!({
151          "id": "3PAETTtuW7aSiyKtn9GuML3RgtV1xdq1mQW",
152          "balance": 141700000
153        });
154        let balance: Balance = json.try_into()?;
155        assert_eq!(
156            "3PAETTtuW7aSiyKtn9GuML3RgtV1xdq1mQW",
157            balance.address().encoded()
158        );
159        assert_eq!(141700000, balance.balance());
160        Ok(())
161    }
162
163    #[test]
164    fn test_create_struct_balance() -> Result<()> {
165        let balance: Balance = Balance::new(
166            Address::from_string("3PAETTtuW7aSiyKtn9GuML3RgtV1xdq1mQW")?,
167            139400003,
168        );
169        assert_eq!(
170            "3PAETTtuW7aSiyKtn9GuML3RgtV1xdq1mQW",
171            balance.address().encoded()
172        );
173        assert_eq!(139400003, balance.balance());
174        Ok(())
175    }
176}
waves_rust/model/account/balance.rs

waves_rust/model/account/
balance.rs
