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
use alloc::vec::Vec;
use serde::{Deserialize, Serialize};
use crate::{
auction::{types::DelegationRate, EraId},
bytesrepr::{self, FromBytes, ToBytes},
CLType, CLTyped, URef, U512,
};
#[derive(PartialEq, Debug, Serialize, Deserialize)]
pub struct Bid {
pub bonding_purse: URef,
pub staked_amount: U512,
pub delegation_rate: DelegationRate,
pub funds_locked: Option<EraId>,
}
impl Bid {
pub fn new_locked(bonding_purse: URef, staked_amount: U512, funds_locked: EraId) -> Self {
Self {
bonding_purse,
staked_amount,
delegation_rate: 0,
funds_locked: Some(funds_locked),
}
}
pub fn can_release_funds(&self) -> bool {
self.funds_locked.is_some()
}
pub fn can_withdraw_funds(&self) -> bool {
self.funds_locked.is_none()
}
}
impl CLTyped for Bid {
fn cl_type() -> CLType {
CLType::Any
}
}
impl ToBytes for Bid {
fn to_bytes(&self) -> Result<Vec<u8>, bytesrepr::Error> {
let mut result = bytesrepr::allocate_buffer(self)?;
result.extend(self.bonding_purse.to_bytes()?);
result.extend(self.staked_amount.to_bytes()?);
result.extend(self.delegation_rate.to_bytes()?);
result.extend(self.funds_locked.to_bytes()?);
Ok(result)
}
fn serialized_length(&self) -> usize {
self.bonding_purse.serialized_length()
+ self.staked_amount.serialized_length()
+ self.delegation_rate.serialized_length()
+ self.funds_locked.serialized_length()
}
}
impl FromBytes for Bid {
fn from_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), bytesrepr::Error> {
let (bonding_purse, bytes) = FromBytes::from_bytes(bytes)?;
let (staked_amount, bytes) = FromBytes::from_bytes(bytes)?;
let (delegation_rate, bytes) = FromBytes::from_bytes(bytes)?;
let (funds_locked, bytes) = FromBytes::from_bytes(bytes)?;
Ok((
Bid {
bonding_purse,
staked_amount,
delegation_rate,
funds_locked,
},
bytes,
))
}
}
#[cfg(test)]
mod tests {
use crate::{
auction::{Bid, DelegationRate, EraId},
bytesrepr, AccessRights, URef, U512,
};
#[test]
fn serialization_roundtrip() {
let founding_validator = Bid {
bonding_purse: URef::new([42; 32], AccessRights::READ_ADD_WRITE),
staked_amount: U512::one(),
delegation_rate: DelegationRate::max_value(),
funds_locked: Some(EraId::max_value() - 1),
};
bytesrepr::test_serialization_roundtrip(&founding_validator);
}
}