1use super::{configuration, Error};
12use crate::{apis::ResponseContent, models};
13use serde::{Deserialize, Serialize};
14
15#[derive(Debug, Clone, Serialize, Deserialize)]
17#[serde(untagged)]
18pub enum GetAccountError {
19 Status400(models::AptosError),
20 Status403(models::AptosError),
21 Status404(models::AptosError),
22 Status410(models::AptosError),
23 Status500(models::AptosError),
24 Status503(models::AptosError),
25 UnknownValue(serde_json::Value),
26}
27
28#[derive(Debug, Clone, Serialize, Deserialize)]
30#[serde(untagged)]
31pub enum GetAccountModuleError {
32 Status400(models::AptosError),
33 Status403(models::AptosError),
34 Status404(models::AptosError),
35 Status410(models::AptosError),
36 Status500(models::AptosError),
37 Status503(models::AptosError),
38 UnknownValue(serde_json::Value),
39}
40
41#[derive(Debug, Clone, Serialize, Deserialize)]
43#[serde(untagged)]
44pub enum GetAccountModulesError {
45 Status400(models::AptosError),
46 Status403(models::AptosError),
47 Status404(models::AptosError),
48 Status410(models::AptosError),
49 Status500(models::AptosError),
50 Status503(models::AptosError),
51 UnknownValue(serde_json::Value),
52}
53
54#[derive(Debug, Clone, Serialize, Deserialize)]
56#[serde(untagged)]
57pub enum GetAccountResourceError {
58 Status400(models::AptosError),
59 Status403(models::AptosError),
60 Status404(models::AptosError),
61 Status410(models::AptosError),
62 Status500(models::AptosError),
63 Status503(models::AptosError),
64 UnknownValue(serde_json::Value),
65}
66
67#[derive(Debug, Clone, Serialize, Deserialize)]
69#[serde(untagged)]
70pub enum GetAccountResourcesError {
71 Status400(models::AptosError),
72 Status403(models::AptosError),
73 Status404(models::AptosError),
74 Status410(models::AptosError),
75 Status500(models::AptosError),
76 Status503(models::AptosError),
77 UnknownValue(serde_json::Value),
78}
79
80pub async fn get_account(
82 configuration: &configuration::Configuration,
83 address: &str,
84 ledger_version: Option<&str>,
85) -> Result<models::AccountData, Error<GetAccountError>> {
86 let local_var_configuration = configuration;
87
88 let local_var_client = &local_var_configuration.client;
89
90 let local_var_uri_str = format!(
91 "{}/accounts/{address}",
92 local_var_configuration.base_path,
93 address = crate::apis::urlencode(address)
94 );
95 let mut local_var_req_builder =
96 local_var_client.request(crate::http::HttpMethod::GET, local_var_uri_str.as_str());
97
98 if let Some(ref local_var_str) = ledger_version {
99 local_var_req_builder =
100 local_var_req_builder.query(&[("ledger_version", &local_var_str.to_string())]);
101 }
102 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
103 local_var_req_builder =
104 local_var_req_builder.header("User-Agent".to_string(), local_var_user_agent.clone());
105 }
106
107 let local_var_req = local_var_req_builder.build()?;
108 let local_var_resp = local_var_client.execute(local_var_req).await?;
109
110 let local_var_status = local_var_resp.status();
111 let local_var_content = local_var_resp.text().await?;
112
113 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
114 ic_cdk::println!("local_var_content: {}", local_var_content);
115 serde_json::from_str(&local_var_content).map_err(Error::from)
116 } else {
117 ic_cdk::println!("local_var_content err: {}", local_var_content);
118 let local_var_entity: Option<GetAccountError> =
119 serde_json::from_str(&local_var_content).ok();
120 let local_var_error = ResponseContent {
121 status: local_var_status,
122 content: local_var_content,
123 entity: local_var_entity,
124 };
125 Err(Error::ResponseError(local_var_error))
126 }
127}
128
129pub async fn get_account_module(
131 configuration: &configuration::Configuration,
132 address: &str,
133 module_name: &str,
134 ledger_version: Option<&str>,
135) -> Result<models::MoveModuleBytecode, Error<GetAccountModuleError>> {
136 let local_var_configuration = configuration;
137
138 let local_var_client = &local_var_configuration.client;
139
140 let local_var_uri_str = format!(
141 "{}/accounts/{address}/module/{module_name}",
142 local_var_configuration.base_path,
143 address = crate::apis::urlencode(address),
144 module_name = crate::apis::urlencode(module_name)
145 );
146 let mut local_var_req_builder =
147 local_var_client.request(crate::http::HttpMethod::GET, local_var_uri_str.as_str());
148
149 if let Some(ref local_var_str) = ledger_version {
150 local_var_req_builder =
151 local_var_req_builder.query(&[("ledger_version", &local_var_str.to_string())]);
152 }
153 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
154 local_var_req_builder =
155 local_var_req_builder.header("User-Agent".to_string(), local_var_user_agent.clone());
156 }
157
158 let local_var_req = local_var_req_builder.build()?;
159 let local_var_resp = local_var_client.execute(local_var_req).await?;
160
161 let local_var_status = local_var_resp.status();
162 let local_var_content = local_var_resp.text().await?;
163
164 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
165 serde_json::from_str(&local_var_content).map_err(Error::from)
166 } else {
167 let local_var_entity: Option<GetAccountModuleError> =
168 serde_json::from_str(&local_var_content).ok();
169 let local_var_error = ResponseContent {
170 status: local_var_status,
171 content: local_var_content,
172 entity: local_var_entity,
173 };
174 Err(Error::ResponseError(local_var_error))
175 }
176}
177
178pub async fn get_account_modules(
180 configuration: &configuration::Configuration,
181 address: &str,
182 ledger_version: Option<&str>,
183 start: Option<&str>,
184 limit: Option<i32>,
185) -> Result<Vec<models::MoveModuleBytecode>, Error<GetAccountModulesError>> {
186 let local_var_configuration = configuration;
187
188 let local_var_client = &local_var_configuration.client;
189
190 let local_var_uri_str = format!(
191 "{}/accounts/{address}/modules",
192 local_var_configuration.base_path,
193 address = crate::apis::urlencode(address)
194 );
195 let mut local_var_req_builder =
196 local_var_client.request(crate::http::HttpMethod::GET, local_var_uri_str.as_str());
197
198 if let Some(ref local_var_str) = ledger_version {
199 local_var_req_builder =
200 local_var_req_builder.query(&[("ledger_version", &local_var_str.to_string())]);
201 }
202 if let Some(ref local_var_str) = start {
203 local_var_req_builder =
204 local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
205 }
206 if let Some(ref local_var_str) = limit {
207 local_var_req_builder =
208 local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
209 }
210 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
211 local_var_req_builder =
212 local_var_req_builder.header("User-Agent".to_string(), local_var_user_agent.clone());
213 }
214
215 let local_var_req = local_var_req_builder.build()?;
216 let local_var_resp = local_var_client.execute(local_var_req).await?;
217
218 let local_var_status = local_var_resp.status();
219 let local_var_content = local_var_resp.text().await?;
220
221 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
222 serde_json::from_str(&local_var_content).map_err(Error::from)
223 } else {
224 let local_var_entity: Option<GetAccountModulesError> =
225 serde_json::from_str(&local_var_content).ok();
226 let local_var_error = ResponseContent {
227 status: local_var_status,
228 content: local_var_content,
229 entity: local_var_entity,
230 };
231 Err(Error::ResponseError(local_var_error))
232 }
233}
234
235pub async fn get_account_resource(
237 configuration: &configuration::Configuration,
238 address: &str,
239 resource_type: &str,
240 ledger_version: Option<&str>,
241) -> Result<models::MoveResource, Error<GetAccountResourceError>> {
242 let local_var_configuration = configuration;
243
244 let local_var_client = &local_var_configuration.client;
245
246 let local_var_uri_str = format!(
247 "{}/accounts/{address}/resource/{resource_type}",
248 local_var_configuration.base_path,
249 address = crate::apis::urlencode(address),
250 resource_type = crate::apis::urlencode(resource_type)
251 );
252 let mut local_var_req_builder =
253 local_var_client.request(crate::http::HttpMethod::GET, local_var_uri_str.as_str());
254
255 if let Some(ref local_var_str) = ledger_version {
256 local_var_req_builder =
257 local_var_req_builder.query(&[("ledger_version", &local_var_str.to_string())]);
258 }
259 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
260 local_var_req_builder =
261 local_var_req_builder.header("User-Agent".to_string(), local_var_user_agent.clone());
262 }
263
264 let local_var_req = local_var_req_builder.build()?;
265 let local_var_resp = local_var_client.execute(local_var_req).await?;
266
267 let local_var_status = local_var_resp.status();
268 let local_var_content = local_var_resp.text().await?;
269
270 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
271 serde_json::from_str(&local_var_content).map_err(Error::from)
272 } else {
273 let local_var_entity: Option<GetAccountResourceError> =
274 serde_json::from_str(&local_var_content).ok();
275 let local_var_error = ResponseContent {
276 status: local_var_status,
277 content: local_var_content,
278 entity: local_var_entity,
279 };
280 Err(Error::ResponseError(local_var_error))
281 }
282}
283
284pub async fn get_account_resources(
286 configuration: &configuration::Configuration,
287 address: &str,
288 ledger_version: Option<&str>,
289 start: Option<&str>,
290 limit: Option<i32>,
291) -> Result<Vec<models::MoveResource>, Error<GetAccountResourcesError>> {
292 let local_var_configuration = configuration;
293
294 let local_var_client = &local_var_configuration.client;
295
296 let local_var_uri_str = format!(
297 "{}/accounts/{address}/resources",
298 local_var_configuration.base_path,
299 address = crate::apis::urlencode(address)
300 );
301 let mut local_var_req_builder =
302 local_var_client.request(crate::http::HttpMethod::GET, local_var_uri_str.as_str());
303
304 if let Some(ref local_var_str) = ledger_version {
305 local_var_req_builder =
306 local_var_req_builder.query(&[("ledger_version", &local_var_str.to_string())]);
307 }
308 if let Some(ref local_var_str) = start {
309 local_var_req_builder =
310 local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
311 }
312 if let Some(ref local_var_str) = limit {
313 local_var_req_builder =
314 local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
315 }
316 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
317 local_var_req_builder =
318 local_var_req_builder.header("User-Agent".to_string(), local_var_user_agent.clone());
319 }
320
321 let local_var_req = local_var_req_builder.build()?;
322 let local_var_resp = local_var_client.execute(local_var_req).await?;
323
324 let local_var_status = local_var_resp.status();
325 let local_var_content = local_var_resp.text().await?;
326
327 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
328 serde_json::from_str(&local_var_content).map_err(Error::from)
329 } else {
330 let local_var_entity: Option<GetAccountResourcesError> =
331 serde_json::from_str(&local_var_content).ok();
332 let local_var_error = ResponseContent {
333 status: local_var_status,
334 content: local_var_content,
335 entity: local_var_entity,
336 };
337 Err(Error::ResponseError(local_var_error))
338 }
339}