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 Ok(t)
49 } else {
50 Err(Error::ParsingFailed(format!(
51 "AbiStruct is expected to be a Composite token, got `{:?}`",
52 value,
53 )))
54 }
55 }
56}
57
58impl TryFrom<&AbiEnum> for Token {
59 type Error = Error;
60
61 fn try_from(value: &AbiEnum) -> Result<Self, Self::Error> {
62 let mut t = Token::parse(&value.name)?;
63
64 if t.type_name() == "option" {
65 return Ok(t);
66 }
67
68 if t.type_name() == "result" {
69 return Ok(t);
70 }
71
72 if let Token::Composite(ref mut c) = t {
73 c.r#type = CompositeType::Enum;
74
75 for (i, v) in value.variants.iter().enumerate() {
76 c.inners.push(CompositeInner {
77 index: i,
78 name: v.name.clone(),
79 token: Token::parse(&v.r#type).unwrap(),
80 kind: CompositeInnerKind::NotUsed,
81 });
82 }
83
84 Ok(t)
85 } else {
86 Err(Error::ParsingFailed(format!(
87 "AbiEnum is expected to be a Composite token, got `{:?}`",
88 value,
89 )))
90 }
91 }
92}
93
94impl TryFrom<&AbiEventStruct> for Token {
95 type Error = Error;
96
97 fn try_from(value: &AbiEventStruct) -> Result<Self, Self::Error> {
98 let mut t = Token::parse(&value.name)?;
99
100 if let Token::Composite(ref mut c) = t {
101 c.r#type = CompositeType::Struct;
102 c.is_event = true;
103
104 for (i, m) in value.members.iter().enumerate() {
105 c.inners.push(CompositeInner {
106 index: i,
107 name: m.name.clone(),
108 token: Token::parse(&m.r#type).unwrap(),
109 kind: m.kind.clone().into(),
110 });
111 }
112
113 Ok(t)
114 } else {
115 Err(Error::ParsingFailed(format!(
116 "AbiEventStruct is expected to be a Composite token, got `{:?}`",
117 value,
118 )))
119 }
120 }
121}
122
123impl TryFrom<&AbiEventEnum> for Token {
124 type Error = Error;
125
126 fn try_from(value: &AbiEventEnum) -> Result<Self, Self::Error> {
127 let mut t = Token::parse(&value.name)?;
128
129 if let Token::Composite(ref mut c) = t {
130 c.r#type = CompositeType::Enum;
131 c.is_event = true;
132
133 for (i, v) in value.variants.iter().enumerate() {
134 c.inners.push(CompositeInner {
135 index: i,
136 name: v.name.clone(),
137 token: Token::parse(&v.r#type).unwrap(),
138 kind: v.kind.clone().into(),
139 });
140 }
141
142 Ok(t)
143 } else {
144 Err(Error::ParsingFailed(format!(
145 "AbiEventEnum is expected to be a Composite token, got `{:?}`",
146 value,
147 )))
148 }
149 }
150}
151
152impl TryFrom<&RawLegacyStruct> for Token {
153 type Error = Error;
154
155 fn try_from(value: &RawLegacyStruct) -> Result<Self, Self::Error> {
156 let mut t = Token::parse(&value.name)?;
157
158 if let Token::Composite(ref mut c) = t {
159 c.r#type = CompositeType::Struct;
160
161 for (i, m) in value.members.iter().enumerate() {
162 c.inners.push(CompositeInner {
163 index: i,
164 name: m.name.clone(),
165 token: Token::parse(&m.r#type).unwrap(),
166 kind: CompositeInnerKind::NotUsed,
167 });
168 }
169
170 Ok(t)
171 } else {
172 Err(Error::ParsingFailed(format!(
173 "RawLegacyStruct is expected to be a Composite token, got `{:?}`",
174 value,
175 )))
176 }
177 }
178}
179
180impl TryFrom<&RawLegacyEvent> for Token {
181 type Error = Error;
182
183 fn try_from(value: &RawLegacyEvent) -> 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 c.is_event = true;
189
190 let mut i = 0;
191
192 for m in value.data.iter() {
193 c.inners.push(CompositeInner {
194 index: i,
195 name: m.name.clone(),
196 token: Token::parse(&m.r#type).unwrap(),
197 kind: CompositeInnerKind::Data,
198 });
199
200 i += 1;
201 }
202
203 for m in value.keys.iter() {
204 c.inners.push(CompositeInner {
205 index: i,
206 name: m.name.clone(),
207 token: Token::parse(&m.r#type).unwrap(),
208 kind: CompositeInnerKind::Key,
209 });
210
211 i += 1;
212 }
213
214 Ok(t)
215 } else {
216 Err(Error::ParsingFailed(format!(
217 "RawLegacyEvent is expected to be a Composite token, got `{:?}`",
218 value,
219 )))
220 }
221 }
222}