chainparser 0.3.0

Parses Solana account data using provided IDL
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

use borsh::BorshDeserialize;
use solana_idl::IdlType;
use solana_sdk::pubkey::Pubkey;

use super::{
    floats::{deserialize_f32, deserialize_f64},
    ChainparserDeserialize,
};
use crate::errors::{ChainparserError, ChainparserResult as Result};

#[derive(Clone, Copy)]
pub struct BorshDeserializer;

impl ChainparserDeserialize for BorshDeserializer {
    fn u8(&self, buf: &mut &[u8]) -> Result<u8> {
        u8::deserialize(buf).map_err(|e| {
            ChainparserError::BorshDeserializeTypeError(
                "u8".to_string(),
                e,
                buf.to_vec(),
            )
        })
    }

    fn u16(&self, buf: &mut &[u8]) -> Result<u16> {
        u16::deserialize(buf).map_err(|e| {
            ChainparserError::BorshDeserializeTypeError(
                "u16".to_string(),
                e,
                buf.to_vec(),
            )
        })
    }

    fn u32(&self, buf: &mut &[u8]) -> Result<u32> {
        u32::deserialize(buf).map_err(|e| {
            ChainparserError::BorshDeserializeTypeError(
                "u32".to_string(),
                e,
                buf.to_vec(),
            )
        })
    }

    fn u64(&self, buf: &mut &[u8]) -> Result<u64> {
        u64::deserialize(buf).map_err(|e| {
            ChainparserError::BorshDeserializeTypeError(
                "u64".to_string(),
                e,
                buf.to_vec(),
            )
        })
    }

    fn u128(&self, buf: &mut &[u8]) -> Result<u128> {
        u128::deserialize(buf).map_err(|e| {
            ChainparserError::BorshDeserializeTypeError(
                "u128".to_string(),
                e,
                buf.to_vec(),
            )
        })
    }

    fn i8(&self, buf: &mut &[u8]) -> Result<i8> {
        i8::deserialize(buf).map_err(|e| {
            ChainparserError::BorshDeserializeTypeError(
                "i8".to_string(),
                e,
                buf.to_vec(),
            )
        })
    }

    fn i16(&self, buf: &mut &[u8]) -> Result<i16> {
        i16::deserialize(buf).map_err(|e| {
            ChainparserError::BorshDeserializeTypeError(
                "i16".to_string(),
                e,
                buf.to_vec(),
            )
        })
    }

    fn i32(&self, buf: &mut &[u8]) -> Result<i32> {
        i32::deserialize(buf).map_err(|e| {
            ChainparserError::BorshDeserializeTypeError(
                "i32".to_string(),
                e,
                buf.to_vec(),
            )
        })
    }

    fn i64(&self, buf: &mut &[u8]) -> Result<i64> {
        i64::deserialize(buf).map_err(|e| {
            ChainparserError::BorshDeserializeTypeError(
                "i64".to_string(),
                e,
                buf.to_vec(),
            )
        })
    }

    fn i128(&self, buf: &mut &[u8]) -> Result<i128> {
        i128::deserialize(buf).map_err(|e| {
            ChainparserError::BorshDeserializeTypeError(
                "i128".to_string(),
                e,
                buf.to_vec(),
            )
        })
    }

    fn f32(&self, buf: &mut &[u8]) -> Result<f32> {
        deserialize_f32(buf)
    }

    fn f64(&self, buf: &mut &[u8]) -> Result<f64> {
        deserialize_f64(buf)
    }

    fn bool(&self, buf: &mut &[u8]) -> Result<bool> {
        bool::deserialize(buf).map_err(|e| {
            ChainparserError::BorshDeserializeTypeError(
                "bool".to_string(),
                e,
                buf.to_vec(),
            )
        })
    }

    fn string(&self, buf: &mut &[u8]) -> Result<String> {
        String::deserialize(buf).map_err(|e| {
            ChainparserError::BorshDeserializeTypeError(
                "String".to_string(),
                e,
                buf.to_vec(),
            )
        })
    }

    fn bytes(&self, buf: &mut &[u8]) -> Result<Vec<u8>> {
        Vec::<u8>::deserialize(buf).map_err(|e| {
            ChainparserError::BorshDeserializeTypeError(
                "bytes".to_string(),
                e,
                buf.to_vec(),
            )
        })
    }

    fn pubkey(&self, buf: &mut &[u8]) -> Result<Pubkey> {
        Pubkey::deserialize(buf).map_err(|e| {
            ChainparserError::BorshDeserializeTypeError(
                "Pubkey".to_string(),
                e,
                buf.to_vec(),
            )
        })
    }

    fn option(&self, buf: &mut &[u8]) -> Result<bool> {
        self.u8(buf).map(|v| v != 0)
    }

    fn coption(&self, _buf: &mut &[u8], _inner: &IdlType) -> Result<bool> {
        Err(ChainparserError::DeserializerDoesNotSupportType(
            "borsh".to_string(),
            "coption".to_string(),
        ))
    }
}