cainome_parser/abi/
conversions.rs1use starknet::core::types::contract::{
2 legacy::{RawLegacyEvent, RawLegacyStruct},
3 AbiEnum, AbiEventEnum, AbiEventStruct, AbiStruct, EventFieldKind,
4 StateMutability as StarknetStateMutability,
5};
6
7use crate::tokens::{CompositeInner, CompositeInnerKind, CompositeType, StateMutability, Token};
8use crate::Error;
9
10impl From<StarknetStateMutability> for StateMutability {
11 fn from(value: StarknetStateMutability) -> Self {
12 match value {
13 StarknetStateMutability::External => StateMutability::External,
14 StarknetStateMutability::View => StateMutability::View,
15 }
16 }
17}
18
19impl From<EventFieldKind> for CompositeInnerKind {
20 fn from(value: EventFieldKind) -> Self {
21 match value {
22 EventFieldKind::Key => CompositeInnerKind::Key,
23 EventFieldKind::Data => CompositeInnerKind::Data,
24 EventFieldKind::Nested => CompositeInnerKind::Nested,
25 EventFieldKind::Flat => CompositeInnerKind::Flat,
26 }
27 }
28}
29
30impl TryFrom<&AbiStruct> for Token {
31 type Error = Error;
32
33 fn try_from(value: &AbiStruct) -> Result<Self, Self::Error> {
34 let mut t = Token::parse(&value.name)?;
35
36 if let Token::Composite(ref mut c) = t {
37 c.r#type = CompositeType::Struct;
38
39 for (i, m) in value.members.iter().enumerate() {
40 c.inners.push(CompositeInner {
41 index: i,
42 name: m.name.clone(),
43 token: Token::parse(&m.r#type).unwrap(),
44 kind: CompositeInnerKind::NotUsed,
45 });
46 }
47
48 if !c.generic_args.is_empty() {
49 let mut token = Token::Composite(c.clone());
50 for (g_name, g_token) in c.generic_args.iter() {
51 token = token.resolve_generic(g_name, &g_token.type_path());
52 }
53
54 return Ok(token);
55 }
56
57 Ok(t)
58 } else {
59 Err(Error::ParsingFailed(format!(
60 "AbiStruct is expected to be a Composite token, got `{:?}`",
61 value,
62 )))
63 }
64 }
65}
66
67impl TryFrom<&AbiEnum> for Token {
68 type Error = Error;
69
70 fn try_from(value: &AbiEnum) -> Result<Self, Self::Error> {
71 let mut t = Token::parse(&value.name)?;
72
73 if let Token::Composite(ref mut c) = t {
74 c.r#type = CompositeType::Enum;
75
76 for (i, v) in value.variants.iter().enumerate() {
77 c.inners.push(CompositeInner {
78 index: i,
79 name: v.name.clone(),
80 token: Token::parse(&v.r#type).unwrap(),
81 kind: CompositeInnerKind::NotUsed,
82 });
83 }
84
85 if !c.generic_args.is_empty() {
86 let mut token = Token::Composite(c.clone());
87 for (g_name, g_token) in c.generic_args.iter() {
88 token = token.resolve_generic(g_name, &g_token.type_path());
89 }
90
91 return Ok(token);
92 }
93
94 Ok(t)
95 } else {
96 Err(Error::ParsingFailed(format!(
97 "AbiEnum is expected to be a Composite token, got `{:?}`",
98 value,
99 )))
100 }
101 }
102}
103
104impl TryFrom<&AbiEventStruct> for Token {
105 type Error = Error;
106
107 fn try_from(value: &AbiEventStruct) -> Result<Self, Self::Error> {
108 let mut t = Token::parse(&value.name)?;
109
110 if let Token::Composite(ref mut c) = t {
111 c.r#type = CompositeType::Struct;
112 c.is_event = true;
113
114 for (i, m) in value.members.iter().enumerate() {
115 c.inners.push(CompositeInner {
116 index: i,
117 name: m.name.clone(),
118 token: Token::parse(&m.r#type).unwrap(),
119 kind: m.kind.clone().into(),
120 });
121 }
122
123 if !c.generic_args.is_empty() {
124 let mut token = Token::Composite(c.clone());
125 for (g_name, g_token) in c.generic_args.iter() {
126 token = token.resolve_generic(g_name, &g_token.type_path());
127 }
128
129 return Ok(token);
130 }
131
132 Ok(t)
133 } else {
134 Err(Error::ParsingFailed(format!(
135 "AbiEventStruct is expected to be a Composite token, got `{:?}`",
136 value,
137 )))
138 }
139 }
140}
141
142impl TryFrom<&AbiEventEnum> for Token {
143 type Error = Error;
144
145 fn try_from(value: &AbiEventEnum) -> Result<Self, Self::Error> {
146 let mut t = Token::parse(&value.name)?;
147
148 if let Token::Composite(ref mut c) = t {
149 c.r#type = CompositeType::Enum;
150 c.is_event = true;
151
152 for (i, v) in value.variants.iter().enumerate() {
153 c.inners.push(CompositeInner {
154 index: i,
155 name: v.name.clone(),
156 token: Token::parse(&v.r#type).unwrap(),
157 kind: v.kind.clone().into(),
158 });
159 }
160
161 if !c.generic_args.is_empty() {
162 let mut token = Token::Composite(c.clone());
163 for (g_name, g_token) in c.generic_args.iter() {
164 token = token.resolve_generic(g_name, &g_token.type_path());
165 }
166
167 return Ok(token);
168 }
169
170 Ok(t)
171 } else {
172 Err(Error::ParsingFailed(format!(
173 "AbiEventEnum is expected to be a Composite token, got `{:?}`",
174 value,
175 )))
176 }
177 }
178}
179
180impl TryFrom<&RawLegacyStruct> for Token {
181 type Error = Error;
182
183 fn try_from(value: &RawLegacyStruct) -> Result<Self, Self::Error> {
184 let mut t = Token::parse(&value.name)?;
185
186 if let Token::Composite(ref mut c) = t {
187 c.r#type = CompositeType::Struct;
188
189 for (i, m) in value.members.iter().enumerate() {
190 c.inners.push(CompositeInner {
191 index: i,
192 name: m.name.clone(),
193 token: Token::parse(&m.r#type).unwrap(),
194 kind: CompositeInnerKind::NotUsed,
195 });
196 }
197
198 Ok(t)
199 } else {
200 Err(Error::ParsingFailed(format!(
201 "RawLegacyStruct is expected to be a Composite token, got `{:?}`",
202 value,
203 )))
204 }
205 }
206}
207
208impl TryFrom<&RawLegacyEvent> for Token {
209 type Error = Error;
210
211 fn try_from(value: &RawLegacyEvent) -> Result<Self, Self::Error> {
212 let mut t = Token::parse(&value.name)?;
213
214 if let Token::Composite(ref mut c) = t {
215 c.r#type = CompositeType::Struct;
216 c.is_event = true;
217
218 let mut i = 0;
219
220 for m in value.data.iter() {
221 c.inners.push(CompositeInner {
222 index: i,
223 name: m.name.clone(),
224 token: Token::parse(&m.r#type).unwrap(),
225 kind: CompositeInnerKind::Data,
226 });
227
228 i += 1;
229 }
230
231 for m in value.keys.iter() {
232 c.inners.push(CompositeInner {
233 index: i,
234 name: m.name.clone(),
235 token: Token::parse(&m.r#type).unwrap(),
236 kind: CompositeInnerKind::Key,
237 });
238
239 i += 1;
240 }
241
242 Ok(t)
243 } else {
244 Err(Error::ParsingFailed(format!(
245 "RawLegacyEvent is expected to be a Composite token, got `{:?}`",
246 value,
247 )))
248 }
249 }
250}