multiversx_sc_meta_lib/abi_json/
endpoint_abi_json.rs

1use multiversx_sc::abi::*;
2use serde::{Deserialize, Serialize};
3
4#[derive(Serialize, Deserialize)]
5pub struct InputAbiJson {
6    #[serde(rename = "name")]
7    pub arg_name: String,
8
9    #[serde(rename = "type")]
10    pub type_name: String,
11
12    /// Bool that is only serialized when true
13    #[serde(default)]
14    #[serde(skip_serializing_if = "Option::is_none")]
15    pub multi_arg: Option<bool>,
16}
17
18impl From<&InputAbi> for InputAbiJson {
19    fn from(abi: &InputAbi) -> Self {
20        InputAbiJson {
21            arg_name: abi.arg_name.to_string(),
22            type_name: abi.type_names.abi.clone(),
23            multi_arg: if abi.multi_arg { Some(true) } else { None },
24        }
25    }
26}
27
28impl From<&InputAbiJson> for InputAbi {
29    fn from(abi: &InputAbiJson) -> Self {
30        InputAbi {
31            arg_name: abi.arg_name.to_string(),
32            type_names: TypeNames::from_abi(abi.type_name.clone()),
33            multi_arg: abi.multi_arg.unwrap_or(false),
34        }
35    }
36}
37
38impl From<InputAbiJson> for InputAbi {
39    fn from(abi: InputAbiJson) -> Self {
40        InputAbi::from(&abi)
41    }
42}
43
44#[derive(Serialize, Deserialize)]
45pub struct OutputAbiJson {
46    #[serde(rename = "name")]
47    #[serde(default)]
48    #[serde(skip_serializing_if = "String::is_empty")]
49    pub output_name: String,
50    #[serde(rename = "type")]
51    pub type_name: String,
52    /// Bool that is only serialized when true
53    #[serde(default)]
54    #[serde(skip_serializing_if = "Option::is_none")]
55    pub multi_result: Option<bool>,
56}
57
58impl From<&OutputAbi> for OutputAbiJson {
59    fn from(abi: &OutputAbi) -> Self {
60        OutputAbiJson {
61            output_name: abi.output_name.clone(),
62            type_name: abi.type_names.abi.clone(),
63            multi_result: if abi.multi_result { Some(true) } else { None },
64        }
65    }
66}
67
68impl From<&OutputAbiJson> for OutputAbi {
69    fn from(abi: &OutputAbiJson) -> Self {
70        OutputAbi {
71            output_name: abi.output_name.clone(),
72            type_names: TypeNames::from_abi(abi.type_name.clone()),
73            multi_result: abi.multi_result.unwrap_or(false),
74        }
75    }
76}
77
78impl From<OutputAbiJson> for OutputAbi {
79    fn from(abi: OutputAbiJson) -> Self {
80        OutputAbi::from(&abi)
81    }
82}
83
84#[derive(Serialize, Deserialize, Default)]
85#[serde(rename_all = "camelCase")]
86pub enum EndpointMutabilityAbiJson {
87    #[default]
88    Mutable,
89    Readonly,
90    Pure,
91}
92
93/// Same as EndpointAbiJson but ignores the name
94#[derive(Serialize, Deserialize)]
95pub struct ConstructorAbiJson {
96    #[serde(default)]
97    #[serde(skip_serializing_if = "Vec::is_empty")]
98    pub docs: Vec<String>,
99    #[serde(rename = "payableInTokens")]
100    #[serde(default)]
101    #[serde(skip_serializing_if = "Vec::is_empty")]
102    pub payable_in_tokens: Vec<String>,
103    pub inputs: Vec<InputAbiJson>,
104    pub outputs: Vec<OutputAbiJson>,
105}
106
107impl From<&EndpointAbi> for ConstructorAbiJson {
108    fn from(abi: &EndpointAbi) -> Self {
109        ConstructorAbiJson {
110            docs: abi.docs.iter().map(|d| d.to_string()).collect(),
111            payable_in_tokens: abi
112                .payable_in_tokens
113                .iter()
114                .map(|d| d.to_string())
115                .collect(),
116            inputs: abi.inputs.iter().map(InputAbiJson::from).collect(),
117            outputs: abi.outputs.iter().map(OutputAbiJson::from).collect(),
118        }
119    }
120}
121
122#[derive(Serialize, Deserialize)]
123pub struct EndpointAbiJson {
124    #[serde(default)]
125    #[serde(skip_serializing_if = "Vec::is_empty")]
126    pub docs: Vec<String>,
127    pub name: String,
128
129    #[serde(default)]
130    #[serde(skip_serializing_if = "Option::is_none")]
131    pub title: Option<String>,
132
133    #[serde(rename = "onlyOwner")]
134    #[serde(default)]
135    #[serde(skip_serializing_if = "Option::is_none")]
136    pub only_owner: Option<bool>,
137
138    #[serde(rename = "onlyAdmin")]
139    #[serde(default)]
140    #[serde(skip_serializing_if = "Option::is_none")]
141    pub only_admin: Option<bool>,
142
143    #[serde(default)]
144    pub mutability: EndpointMutabilityAbiJson,
145
146    #[serde(rename = "payableInTokens")]
147    #[serde(default)]
148    #[serde(skip_serializing_if = "Vec::is_empty")]
149    pub payable_in_tokens: Vec<String>,
150
151    pub inputs: Vec<InputAbiJson>,
152
153    pub outputs: Vec<OutputAbiJson>,
154
155    #[serde(default)]
156    #[serde(skip_serializing_if = "Vec::is_empty")]
157    pub labels: Vec<String>,
158
159    #[serde(default)]
160    #[serde(skip_serializing_if = "Option::is_none")]
161    pub allow_multiple_var_args: Option<bool>,
162}
163
164impl From<&EndpointAbi> for EndpointAbiJson {
165    fn from(abi: &EndpointAbi) -> Self {
166        EndpointAbiJson {
167            docs: abi.docs.iter().map(|d| d.to_string()).collect(),
168            name: abi.name.to_string(),
169            title: abi.title.clone(),
170            only_owner: if abi.only_owner { Some(true) } else { None },
171            only_admin: if abi.only_admin { Some(true) } else { None },
172            mutability: match abi.mutability {
173                EndpointMutabilityAbi::Mutable => EndpointMutabilityAbiJson::Mutable,
174                EndpointMutabilityAbi::Readonly => EndpointMutabilityAbiJson::Readonly,
175                EndpointMutabilityAbi::Pure => EndpointMutabilityAbiJson::Pure,
176            },
177            payable_in_tokens: abi
178                .payable_in_tokens
179                .iter()
180                .map(|d| d.to_string())
181                .collect(),
182            inputs: abi.inputs.iter().map(InputAbiJson::from).collect(),
183            outputs: abi.outputs.iter().map(OutputAbiJson::from).collect(),
184            labels: abi.labels.clone(),
185            allow_multiple_var_args: if abi.allow_multiple_var_args {
186                Some(true)
187            } else {
188                None
189            },
190        }
191    }
192}
193
194impl From<&EndpointAbiJson> for EndpointAbi {
195    fn from(abi: &EndpointAbiJson) -> Self {
196        EndpointAbi {
197            docs: abi.docs.iter().map(|d| d.to_string()).collect(),
198            name: abi.name.to_string(),
199            only_owner: abi.only_owner.unwrap_or(false),
200            only_admin: abi.only_admin.unwrap_or(false),
201            mutability: match abi.mutability {
202                EndpointMutabilityAbiJson::Mutable => EndpointMutabilityAbi::Mutable,
203                EndpointMutabilityAbiJson::Readonly => EndpointMutabilityAbi::Readonly,
204                EndpointMutabilityAbiJson::Pure => EndpointMutabilityAbi::Pure,
205            },
206            payable_in_tokens: abi
207                .payable_in_tokens
208                .iter()
209                .map(|d| d.to_string())
210                .collect(),
211            inputs: abi.inputs.iter().map(InputAbi::from).collect(),
212            outputs: abi.outputs.iter().map(OutputAbi::from).collect(),
213            labels: abi.labels.clone(),
214            allow_multiple_var_args: abi.allow_multiple_var_args.unwrap_or(false),
215            rust_method_name: abi.name.clone(),
216            title: None,
217            endpoint_type: EndpointTypeAbi::Endpoint,
218        }
219    }
220}
221
222impl From<EndpointAbiJson> for EndpointAbi {
223    fn from(abi: EndpointAbiJson) -> Self {
224        EndpointAbi::from(&abi)
225    }
226}
227
228impl From<&ConstructorAbiJson> for EndpointAbi {
229    fn from(abi: &ConstructorAbiJson) -> Self {
230        EndpointAbi {
231            docs: abi.docs.iter().map(|d| d.to_string()).collect(),
232            name: "".to_string(),
233            only_owner: false,
234            only_admin: false,
235            mutability: EndpointMutabilityAbi::Mutable,
236            payable_in_tokens: abi
237                .payable_in_tokens
238                .iter()
239                .map(|d| d.to_string())
240                .collect(),
241            inputs: abi.inputs.iter().map(InputAbi::from).collect(),
242            outputs: abi.outputs.iter().map(OutputAbi::from).collect(),
243            labels: vec![],
244            allow_multiple_var_args: false,
245            rust_method_name: "".to_string(),
246            title: None,
247            endpoint_type: EndpointTypeAbi::Init,
248        }
249    }
250}
251
252impl From<ConstructorAbiJson> for EndpointAbi {
253    fn from(abi: ConstructorAbiJson) -> Self {
254        EndpointAbi::from(&abi)
255    }
256}
multiversx_sc_meta_lib/abi_json/endpoint_abi_json.rs

multiversx_sc_meta_lib/abi_json/
endpoint_abi_json.rs
