Skip to main content

aptos_client_icp/apis/
accounts_api.rs

1/*
2 * Aptos Node API
3 *
4 * The Aptos Node API is a RESTful API for client applications to interact with the Aptos blockchain.
5 *
6 * The version of the OpenAPI document: 1.2.0
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use super::{configuration, Error};
12use crate::{apis::ResponseContent, models};
13use serde::{Deserialize, Serialize};
14
15/// struct for typed errors of method [`get_account`]
16#[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/// struct for typed errors of method [`get_account_module`]
29#[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/// struct for typed errors of method [`get_account_modules`]
42#[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/// struct for typed errors of method [`get_account_resource`]
55#[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/// struct for typed errors of method [`get_account_resources`]
68#[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
80/// Return the authentication key and the sequence number for an account address. Optionally, a ledger version can be specified. If the ledger version is not specified in the request, the latest ledger version is used.
81pub 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
129/// Retrieves an individual module from a given account and at a specific ledger version. If the ledger version is not specified in the request, the latest ledger version is used.  The Aptos nodes prune account state history, via a configurable time window. If the requested ledger version has been pruned, the server responds with a 410.
130pub 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
178/// Retrieves all account modules' bytecode for a given account at a specific ledger version. If the ledger version is not specified in the request, the latest ledger version is used.  The Aptos nodes prune account state history, via a configurable time window. If the requested ledger version has been pruned, the server responds with a 410.
179pub 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
235/// Retrieves an individual resource from a given account and at a specific ledger version. If the ledger version is not specified in the request, the latest ledger version is used.  The Aptos nodes prune account state history, via a configurable time window. If the requested ledger version has been pruned, the server responds with a 410.
236pub 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
284/// Retrieves all account resources for a given account and a specific ledger version.  If the ledger version is not specified in the request, the latest ledger version is used.  The Aptos nodes prune account state history, via a configurable time window. If the requested ledger version has been pruned, the server responds with a 410.
285pub 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}