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
use crate::TokenAmount;
use cid::Cid;
use encoding::tuple::*;
use num_bigint::bigint_ser;
#[derive(PartialEq, Eq, Clone, Debug, Serialize_tuple, Deserialize_tuple)]
pub struct ActorState {
pub code: Cid,
pub state: Cid,
pub sequence: u64,
#[serde(with = "bigint_ser")]
pub balance: TokenAmount,
}
impl ActorState {
pub fn new(code: Cid, state: Cid, balance: TokenAmount, sequence: u64) -> Self {
Self {
code,
state,
sequence,
balance,
}
}
pub fn deduct_funds(&mut self, amt: &TokenAmount) -> Result<(), String> {
if &self.balance < amt {
return Err("Not enough funds".to_owned());
}
self.balance -= amt;
Ok(())
}
pub fn deposit_funds(&mut self, amt: &TokenAmount) {
self.balance += amt;
}
}
#[cfg(feature = "json")]
pub mod json {
use super::*;
use crate::TokenAmount;
use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
use std::str::FromStr;
#[derive(Deserialize, Serialize)]
#[serde(transparent)]
pub struct ActorStateJson(#[serde(with = "self")] pub ActorState);
#[derive(Serialize)]
#[serde(transparent)]
pub struct ActorStateJsonRef<'a>(#[serde(with = "self")] pub &'a ActorState);
impl From<ActorStateJson> for ActorState {
fn from(wrapper: ActorStateJson) -> Self {
wrapper.0
}
}
pub fn serialize<S>(m: &ActorState, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
#[derive(Serialize)]
#[serde(rename_all = "PascalCase")]
struct ActorStateSer<'a> {
#[serde(with = "cid::json")]
pub code: &'a Cid,
#[serde(rename = "Head", with = "cid::json")]
pub state: &'a Cid,
#[serde(rename = "Nonce")]
pub sequence: u64,
pub balance: String,
}
ActorStateSer {
code: &m.code,
state: &m.state,
sequence: m.sequence,
balance: m.balance.to_str_radix(10),
}
.serialize(serializer)
}
pub fn deserialize<'de, D>(deserializer: D) -> Result<ActorState, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(rename_all = "PascalCase")]
struct ActorStateDe {
#[serde(with = "cid::json")]
pub code: Cid,
#[serde(rename = "Head", with = "cid::json")]
pub state: Cid,
#[serde(rename = "Nonce")]
pub sequence: u64,
pub balance: String,
}
let ActorStateDe {
code,
state,
sequence,
balance,
} = Deserialize::deserialize(deserializer)?;
Ok(ActorState {
code,
state,
sequence,
balance: TokenAmount::from_str(&balance).map_err(de::Error::custom)?,
})
}
}