devol-accounts-kit 0.3.4

SDK for interacting with the DeVol Network option trading platform on the Solana blockchain
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

pub const LP_TRADE_LOG_ID_OFFSET: usize = 0;
pub const LP_TRADE_LOG_TIME_OFFSET: usize = 8;
pub const LP_TRADE_LOG_WORKER_ID_OFFSET: usize = 16;
pub const LP_TRADE_LOG_TASK_ID_OFFSET: usize = 20;
pub const LP_TRADE_LOG_COUNTER_OFFSET: usize = 24;
pub const LP_TRADE_LOG_COST_OFFSET: usize = 32;
pub const LP_TRADE_LOG_PS_OFFSET: usize = 40;
pub const LP_TRADE_LOG_PS_PX_OFFSET: usize = 44;
pub const LP_TRADE_LOG_SIZE: usize = 52;

#[derive(Clone, Copy)]
#[repr(C)]
pub struct LpTradeLog {
    // 8 bytes, LP_TRADE_LOG_ID_OFFSET
    pub id: [u8; 8],
    // 8 bytes, LP_TRADE_LOG_TIME_OFFSET
    pub time: [u8; 8],
    // 4 bytes, LP_TRADE_LOG_WORKER_ID_OFFSET
    pub worker_id: u32,
    // 4 bytes, LP_TRADE_LOG_TASK_ID_OFFSET
    pub task_id: u32,
    // 8 bytes, LP_TRADE_LOG_COUNTER_OFFSET
    pub counter: [u8; 8],
    // 8 bytes, LP_TRADE_LOG_COST_OFFSET
    pub cost: [u8; 8],
    // 4 bytes, LP_TRADE_LOG_PS_OFFSET
    pub ps: i32,
    // 8 bytes, LP_TRADE_LOG_PS_PX_OFFSET
    pub ps_px: [u8; 8],
}

impl LpTradeLog {
    #[inline(always)]
    pub fn get_id(&self) -> i64 {
        i64::from_ne_bytes(self.id)
    }

    #[inline(always)]
    pub fn set_id(&mut self, value: i64) {
        self.id = value.to_ne_bytes();
    }

    #[inline(always)]
    pub fn get_time(&self) -> i64 {
        i64::from_ne_bytes(self.time)
    }

    #[inline(always)]
    pub fn set_time(&mut self, value: i64) {
        self.time = value.to_ne_bytes();
    }

    #[inline(always)]
    pub fn get_counter(&self) -> i64 {
        i64::from_ne_bytes(self.counter)
    }

    #[inline(always)]
    pub fn set_counter(&mut self, value: i64) {
        self.counter = value.to_ne_bytes();
    }

    #[inline(always)]
    pub fn get_cost(&self) -> i64 {
        i64::from_ne_bytes(self.cost)
    }

    #[inline(always)]
    pub fn set_cost(&mut self, value: i64) {
        self.cost = value.to_ne_bytes();
    }

    #[inline(always)]
    pub fn get_ps_px(&self) -> i64 {
        i64::from_ne_bytes(self.ps_px)
    }

    #[inline(always)]
    pub fn set_ps_px(&mut self, value: i64) {
        self.ps_px = value.to_ne_bytes();
    }
}

#[cfg(test)]
impl Default for LpTradeLog {
    fn default() -> Self {
        Self {
            id: [0; 8],
            time: [0; 8],
            worker_id: 0,
            task_id: 0,
            counter: [0; 8],
            cost: [0; 8],
            ps: 0,
            ps_px: [0; 8],
        }
    }
}

#[cfg(test)]
mod tests {
    use std::mem;
    use super::*;

    #[test]
    fn test_lp_trade_log_offsets() {
        let log = LpTradeLog::default();
        let base_ptr = &log as *const _ as usize;

        // checking fields size and offset
        assert_eq!(
            &log.id as *const _ as usize - base_ptr,
            LP_TRADE_LOG_ID_OFFSET
        );
        assert_eq!(
            &log.time as *const _ as usize - base_ptr,
            LP_TRADE_LOG_TIME_OFFSET
        );
        assert_eq!(
            &log.worker_id as *const _ as usize - base_ptr,
            LP_TRADE_LOG_WORKER_ID_OFFSET
        );
        assert_eq!(
            &log.task_id as *const _ as usize - base_ptr,
            LP_TRADE_LOG_TASK_ID_OFFSET
        );
        assert_eq!(
            &log.counter as *const _ as usize - base_ptr,
            LP_TRADE_LOG_COUNTER_OFFSET
        );
        assert_eq!(
            &log.cost as *const _ as usize - base_ptr,
            LP_TRADE_LOG_COST_OFFSET
        );
        assert_eq!(
            &log.ps as *const _ as usize - base_ptr,
            LP_TRADE_LOG_PS_OFFSET
        );
        assert_eq!(
            &log.ps_px as *const _ as usize - base_ptr,
            LP_TRADE_LOG_PS_PX_OFFSET
        );

        // checking total size
        assert_eq!(mem::size_of::<LpTradeLog>(), LP_TRADE_LOG_SIZE);
    }
}