1use reqwest;
13
14use crate::apis::ResponseContent;
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum ContractFtAddressAddressBalanceConfirmedGetError {
22 Status401(Vec<crate::models::ErrorResponse>),
23 UnknownValue(serde_json::Value),
24}
25
26#[derive(Debug, Clone, Serialize, Deserialize)]
28#[serde(untagged)]
29pub enum ContractFtAddressAddressBalanceGetError {
30 Status401(Vec<crate::models::ErrorResponse>),
31 UnknownValue(serde_json::Value),
32}
33
34#[derive(Debug, Clone, Serialize, Deserialize)]
36#[serde(untagged)]
37pub enum ContractFtAddressAddressCodeHashGenesisTxGetError {
38 Status401(Vec<crate::models::ErrorResponse>),
39 UnknownValue(serde_json::Value),
40}
41
42#[derive(Debug, Clone, Serialize, Deserialize)]
44#[serde(untagged)]
45pub enum ContractFtAddressAddressUtxoGetError {
46 Status401(Vec<crate::models::ErrorResponse>),
47 UnknownValue(serde_json::Value),
48}
49
50#[derive(Debug, Clone, Serialize, Deserialize)]
52#[serde(untagged)]
53pub enum ContractFtGenesisCodeHashGenesisCirculationGetError {
54 UnknownValue(serde_json::Value),
55}
56
57#[derive(Debug, Clone, Serialize, Deserialize)]
59#[serde(untagged)]
60pub enum ContractNftAddressAddressCountConfirmedGetError {
61 Status401(Vec<crate::models::ErrorResponse>),
62 UnknownValue(serde_json::Value),
63}
64
65#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum ContractNftAddressAddressSummaryGetError {
69 Status401(Vec<crate::models::ErrorResponse>),
70 UnknownValue(serde_json::Value),
71}
72
73#[derive(Debug, Clone, Serialize, Deserialize)]
75#[serde(untagged)]
76pub enum ContractNftAddressAddressUtxoGetError {
77 Status401(Vec<crate::models::ErrorResponse>),
78 UnknownValue(serde_json::Value),
79}
80
81#[derive(Debug, Clone, Serialize, Deserialize)]
83#[serde(untagged)]
84pub enum ContractNftGenesisCodeHashGenesisSummaryGetError {
85 Status401(Vec<crate::models::ErrorResponse>),
86 UnknownValue(serde_json::Value),
87}
88
89#[derive(Debug, Clone, Serialize, Deserialize)]
91#[serde(untagged)]
92pub enum ContractNftGenesisCodeHashGenesisUtxoGetError {
93 Status401(Vec<crate::models::ErrorResponse>),
94 UnknownValue(serde_json::Value),
95}
96
97#[derive(Debug, Clone, Serialize, Deserialize)]
99#[serde(untagged)]
100pub enum ContractNftSellAddressAddressUtxoGetError {
101 Status401(Vec<crate::models::ErrorResponse>),
102 UnknownValue(serde_json::Value),
103}
104
105#[derive(Debug, Clone, Serialize, Deserialize)]
107#[serde(untagged)]
108pub enum ContractNftSellGenesisCodeHashGenesisUtxoGetError {
109 Status401(Vec<crate::models::ErrorResponse>),
110 UnknownValue(serde_json::Value),
111}
112
113#[derive(Debug, Clone, Serialize, Deserialize)]
115#[serde(untagged)]
116pub enum ContractUniqueGenesisCodeHashGenesisUtxoGetError {
117 Status401(Vec<crate::models::ErrorResponse>),
118 UnknownValue(serde_json::Value),
119}
120
121
122pub async fn contract_ft_address_address_balance_confirmed_get(configuration: &configuration::Configuration, address: &str, code_hash: &str, genesis: &str) -> Result<i64, Error<ContractFtAddressAddressBalanceConfirmedGetError>> {
123 let local_var_configuration = configuration;
124
125 let local_var_client = &local_var_configuration.client;
126
127 let local_var_uri_str = format!("{}/contract/ft/address/{address}/balance/confirmed", local_var_configuration.base_path, address=crate::apis::urlencode(address));
128 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
129
130 local_var_req_builder = local_var_req_builder.query(&[("codeHash", &code_hash.to_string())]);
131 local_var_req_builder = local_var_req_builder.query(&[("genesis", &genesis.to_string())]);
132 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
133 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
134 }
135 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
136 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
137 };
138
139 let local_var_req = local_var_req_builder.build()?;
140 let local_var_resp = local_var_client.execute(local_var_req).await?;
141
142 let local_var_status = local_var_resp.status();
143 let local_var_content = local_var_resp.text().await?;
144
145 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
146 serde_json::from_str(&local_var_content).map_err(Error::from)
147 } else {
148 let local_var_entity: Option<ContractFtAddressAddressBalanceConfirmedGetError> = serde_json::from_str(&local_var_content).ok();
149 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
150 Err(Error::ResponseError(local_var_error))
151 }
152}
153
154pub async fn contract_ft_address_address_balance_get(configuration: &configuration::Configuration, address: &str, code_hash: Option<&str>, genesis: Option<&str>) -> Result<Vec<crate::models::ContractFtBalance>, Error<ContractFtAddressAddressBalanceGetError>> {
155 let local_var_configuration = configuration;
156
157 let local_var_client = &local_var_configuration.client;
158
159 let local_var_uri_str = format!("{}/contract/ft/address/{address}/balance", local_var_configuration.base_path, address=crate::apis::urlencode(address));
160 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
161
162 if let Some(ref local_var_str) = code_hash {
163 local_var_req_builder = local_var_req_builder.query(&[("codeHash", &local_var_str.to_string())]);
164 }
165 if let Some(ref local_var_str) = genesis {
166 local_var_req_builder = local_var_req_builder.query(&[("genesis", &local_var_str.to_string())]);
167 }
168 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
169 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
170 }
171 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
172 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
173 };
174
175 let local_var_req = local_var_req_builder.build()?;
176 let local_var_resp = local_var_client.execute(local_var_req).await?;
177
178 let local_var_status = local_var_resp.status();
179 let local_var_content = local_var_resp.text().await?;
180
181 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
182 serde_json::from_str(&local_var_content).map_err(Error::from)
183 } else {
184 let local_var_entity: Option<ContractFtAddressAddressBalanceGetError> = serde_json::from_str(&local_var_content).ok();
185 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
186 Err(Error::ResponseError(local_var_error))
187 }
188}
189
190pub async fn contract_ft_address_address_code_hash_genesis_tx_get(configuration: &configuration::Configuration, address: &str, code_hash: &str, genesis: &str, limit: Option<i64>, flag: Option<&str>) -> Result<Vec<crate::models::ContractFtAddressTx>, Error<ContractFtAddressAddressCodeHashGenesisTxGetError>> {
191 let local_var_configuration = configuration;
192
193 let local_var_client = &local_var_configuration.client;
194
195 let local_var_uri_str = format!("{}/contract/ft/address/{address}/{codeHash}/{genesis}/tx", local_var_configuration.base_path, address=crate::apis::urlencode(address), codeHash=crate::apis::urlencode(code_hash), genesis=crate::apis::urlencode(genesis));
196 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
197
198 if let Some(ref local_var_str) = limit {
199 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
200 }
201 if let Some(ref local_var_str) = flag {
202 local_var_req_builder = local_var_req_builder.query(&[("flag", &local_var_str.to_string())]);
203 }
204 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
205 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
206 }
207 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
208 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
209 };
210
211 let local_var_req = local_var_req_builder.build()?;
212 let local_var_resp = local_var_client.execute(local_var_req).await?;
213
214 let local_var_status = local_var_resp.status();
215 let local_var_content = local_var_resp.text().await?;
216
217 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
218 serde_json::from_str(&local_var_content).map_err(Error::from)
219 } else {
220 let local_var_entity: Option<ContractFtAddressAddressCodeHashGenesisTxGetError> = serde_json::from_str(&local_var_content).ok();
221 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
222 Err(Error::ResponseError(local_var_error))
223 }
224}
225
226pub async fn contract_ft_address_address_utxo_get(configuration: &configuration::Configuration, address: &str, code_hash: Option<&str>, genesis: Option<&str>, flag: Option<&str>) -> Result<Vec<crate::models::ContractFtUtxo>, Error<ContractFtAddressAddressUtxoGetError>> {
227 let local_var_configuration = configuration;
228
229 let local_var_client = &local_var_configuration.client;
230
231 let local_var_uri_str = format!("{}/contract/ft/address/{address}/utxo", local_var_configuration.base_path, address=crate::apis::urlencode(address));
232 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
233
234 if let Some(ref local_var_str) = code_hash {
235 local_var_req_builder = local_var_req_builder.query(&[("codeHash", &local_var_str.to_string())]);
236 }
237 if let Some(ref local_var_str) = genesis {
238 local_var_req_builder = local_var_req_builder.query(&[("genesis", &local_var_str.to_string())]);
239 }
240 if let Some(ref local_var_str) = flag {
241 local_var_req_builder = local_var_req_builder.query(&[("flag", &local_var_str.to_string())]);
242 }
243 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
244 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
245 }
246 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
247 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
248 };
249
250 let local_var_req = local_var_req_builder.build()?;
251 let local_var_resp = local_var_client.execute(local_var_req).await?;
252
253 let local_var_status = local_var_resp.status();
254 let local_var_content = local_var_resp.text().await?;
255
256 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
257 serde_json::from_str(&local_var_content).map_err(Error::from)
258 } else {
259 let local_var_entity: Option<ContractFtAddressAddressUtxoGetError> = serde_json::from_str(&local_var_content).ok();
260 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
261 Err(Error::ResponseError(local_var_error))
262 }
263}
264
265pub async fn contract_ft_genesis_code_hash_genesis_circulation_get(configuration: &configuration::Configuration, code_hash: &str, genesis: &str) -> Result<crate::models::ContractFtGenesisCirculation, Error<ContractFtGenesisCodeHashGenesisCirculationGetError>> {
266 let local_var_configuration = configuration;
267
268 let local_var_client = &local_var_configuration.client;
269
270 let local_var_uri_str = format!("{}/contract/ft/genesis/{codeHash}/{genesis}/circulation", local_var_configuration.base_path, codeHash=crate::apis::urlencode(code_hash), genesis=crate::apis::urlencode(genesis));
271 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
272
273 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
274 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
275 }
276 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
277 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
278 };
279
280 let local_var_req = local_var_req_builder.build()?;
281 let local_var_resp = local_var_client.execute(local_var_req).await?;
282
283 let local_var_status = local_var_resp.status();
284 let local_var_content = local_var_resp.text().await?;
285
286 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
287 serde_json::from_str(&local_var_content).map_err(Error::from)
288 } else {
289 let local_var_entity: Option<ContractFtGenesisCodeHashGenesisCirculationGetError> = serde_json::from_str(&local_var_content).ok();
290 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
291 Err(Error::ResponseError(local_var_error))
292 }
293}
294
295pub async fn contract_nft_address_address_count_confirmed_get(configuration: &configuration::Configuration, address: &str, code_hash: &str, genesis: &str) -> Result<i32, Error<ContractNftAddressAddressCountConfirmedGetError>> {
296 let local_var_configuration = configuration;
297
298 let local_var_client = &local_var_configuration.client;
299
300 let local_var_uri_str = format!("{}/contract/nft/address/{address}/count/confirmed", local_var_configuration.base_path, address=crate::apis::urlencode(address));
301 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
302
303 local_var_req_builder = local_var_req_builder.query(&[("codeHash", &code_hash.to_string())]);
304 local_var_req_builder = local_var_req_builder.query(&[("genesis", &genesis.to_string())]);
305 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
306 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
307 }
308 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
309 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
310 };
311
312 let local_var_req = local_var_req_builder.build()?;
313 let local_var_resp = local_var_client.execute(local_var_req).await?;
314
315 let local_var_status = local_var_resp.status();
316 let local_var_content = local_var_resp.text().await?;
317
318 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
319 serde_json::from_str(&local_var_content).map_err(Error::from)
320 } else {
321 let local_var_entity: Option<ContractNftAddressAddressCountConfirmedGetError> = serde_json::from_str(&local_var_content).ok();
322 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
323 Err(Error::ResponseError(local_var_error))
324 }
325}
326
327pub async fn contract_nft_address_address_summary_get(configuration: &configuration::Configuration, address: &str) -> Result<Vec<crate::models::ContractNftAddressSummary>, Error<ContractNftAddressAddressSummaryGetError>> {
328 let local_var_configuration = configuration;
329
330 let local_var_client = &local_var_configuration.client;
331
332 let local_var_uri_str = format!("{}/contract/nft/address/{address}/summary", local_var_configuration.base_path, address=crate::apis::urlencode(address));
333 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
334
335 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
336 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
337 }
338 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
339 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
340 };
341
342 let local_var_req = local_var_req_builder.build()?;
343 let local_var_resp = local_var_client.execute(local_var_req).await?;
344
345 let local_var_status = local_var_resp.status();
346 let local_var_content = local_var_resp.text().await?;
347
348 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
349 serde_json::from_str(&local_var_content).map_err(Error::from)
350 } else {
351 let local_var_entity: Option<ContractNftAddressAddressSummaryGetError> = serde_json::from_str(&local_var_content).ok();
352 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
353 Err(Error::ResponseError(local_var_error))
354 }
355}
356
357pub async fn contract_nft_address_address_utxo_get(configuration: &configuration::Configuration, address: &str, code_hash: Option<&str>, genesis: Option<&str>, limit: Option<i32>, flag: Option<&str>) -> Result<Vec<crate::models::ContractNftUtxo>, Error<ContractNftAddressAddressUtxoGetError>> {
358 let local_var_configuration = configuration;
359
360 let local_var_client = &local_var_configuration.client;
361
362 let local_var_uri_str = format!("{}/contract/nft/address/{address}/utxo", local_var_configuration.base_path, address=crate::apis::urlencode(address));
363 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
364
365 if let Some(ref local_var_str) = code_hash {
366 local_var_req_builder = local_var_req_builder.query(&[("codeHash", &local_var_str.to_string())]);
367 }
368 if let Some(ref local_var_str) = genesis {
369 local_var_req_builder = local_var_req_builder.query(&[("genesis", &local_var_str.to_string())]);
370 }
371 if let Some(ref local_var_str) = limit {
372 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
373 }
374 if let Some(ref local_var_str) = flag {
375 local_var_req_builder = local_var_req_builder.query(&[("flag", &local_var_str.to_string())]);
376 }
377 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
378 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
379 }
380 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
381 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
382 };
383
384 let local_var_req = local_var_req_builder.build()?;
385 let local_var_resp = local_var_client.execute(local_var_req).await?;
386
387 let local_var_status = local_var_resp.status();
388 let local_var_content = local_var_resp.text().await?;
389
390 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
391 serde_json::from_str(&local_var_content).map_err(Error::from)
392 } else {
393 let local_var_entity: Option<ContractNftAddressAddressUtxoGetError> = serde_json::from_str(&local_var_content).ok();
394 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
395 Err(Error::ResponseError(local_var_error))
396 }
397}
398
399pub async fn contract_nft_genesis_code_hash_genesis_summary_get(configuration: &configuration::Configuration, code_hash: &str, genesis: &str) -> Result<Vec<crate::models::ContractNftGenesisSummary>, Error<ContractNftGenesisCodeHashGenesisSummaryGetError>> {
400 let local_var_configuration = configuration;
401
402 let local_var_client = &local_var_configuration.client;
403
404 let local_var_uri_str = format!("{}/contract/nft/genesis/{codeHash}/{genesis}/summary", local_var_configuration.base_path, codeHash=crate::apis::urlencode(code_hash), genesis=crate::apis::urlencode(genesis));
405 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
406
407 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
408 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
409 }
410 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
411 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
412 };
413
414 let local_var_req = local_var_req_builder.build()?;
415 let local_var_resp = local_var_client.execute(local_var_req).await?;
416
417 let local_var_status = local_var_resp.status();
418 let local_var_content = local_var_resp.text().await?;
419
420 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
421 serde_json::from_str(&local_var_content).map_err(Error::from)
422 } else {
423 let local_var_entity: Option<ContractNftGenesisCodeHashGenesisSummaryGetError> = serde_json::from_str(&local_var_content).ok();
424 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
425 Err(Error::ResponseError(local_var_error))
426 }
427}
428
429pub async fn contract_nft_genesis_code_hash_genesis_utxo_get(configuration: &configuration::Configuration, code_hash: &str, genesis: &str, token_index: Option<i64>, max: Option<i64>, min: Option<i64>) -> Result<Vec<crate::models::ContractNftUtxo>, Error<ContractNftGenesisCodeHashGenesisUtxoGetError>> {
430 let local_var_configuration = configuration;
431
432 let local_var_client = &local_var_configuration.client;
433
434 let local_var_uri_str = format!("{}/contract/nft/genesis/{codeHash}/{genesis}/utxo", local_var_configuration.base_path, codeHash=crate::apis::urlencode(code_hash), genesis=crate::apis::urlencode(genesis));
435 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
436
437 if let Some(ref local_var_str) = token_index {
438 local_var_req_builder = local_var_req_builder.query(&[("tokenIndex", &local_var_str.to_string())]);
439 }
440 if let Some(ref local_var_str) = max {
441 local_var_req_builder = local_var_req_builder.query(&[("max", &local_var_str.to_string())]);
442 }
443 if let Some(ref local_var_str) = min {
444 local_var_req_builder = local_var_req_builder.query(&[("min", &local_var_str.to_string())]);
445 }
446 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
447 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
448 }
449 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
450 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
451 };
452
453 let local_var_req = local_var_req_builder.build()?;
454 let local_var_resp = local_var_client.execute(local_var_req).await?;
455
456 let local_var_status = local_var_resp.status();
457 let local_var_content = local_var_resp.text().await?;
458
459 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
460 serde_json::from_str(&local_var_content).map_err(Error::from)
461 } else {
462 let local_var_entity: Option<ContractNftGenesisCodeHashGenesisUtxoGetError> = serde_json::from_str(&local_var_content).ok();
463 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
464 Err(Error::ResponseError(local_var_error))
465 }
466}
467
468pub async fn contract_nft_sell_address_address_utxo_get(configuration: &configuration::Configuration, address: &str, code_hash: Option<&str>, genesis: Option<&str>, limit: Option<i32>, flag: Option<&str>) -> Result<Vec<crate::models::ContractNftSellUtxo>, Error<ContractNftSellAddressAddressUtxoGetError>> {
469 let local_var_configuration = configuration;
470
471 let local_var_client = &local_var_configuration.client;
472
473 let local_var_uri_str = format!("{}/contract/nft/sell/address/{address}/utxo", local_var_configuration.base_path, address=crate::apis::urlencode(address));
474 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
475
476 if let Some(ref local_var_str) = code_hash {
477 local_var_req_builder = local_var_req_builder.query(&[("codeHash", &local_var_str.to_string())]);
478 }
479 if let Some(ref local_var_str) = genesis {
480 local_var_req_builder = local_var_req_builder.query(&[("genesis", &local_var_str.to_string())]);
481 }
482 if let Some(ref local_var_str) = limit {
483 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
484 }
485 if let Some(ref local_var_str) = flag {
486 local_var_req_builder = local_var_req_builder.query(&[("flag", &local_var_str.to_string())]);
487 }
488 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
489 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
490 }
491 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
492 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
493 };
494
495 let local_var_req = local_var_req_builder.build()?;
496 let local_var_resp = local_var_client.execute(local_var_req).await?;
497
498 let local_var_status = local_var_resp.status();
499 let local_var_content = local_var_resp.text().await?;
500
501 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
502 serde_json::from_str(&local_var_content).map_err(Error::from)
503 } else {
504 let local_var_entity: Option<ContractNftSellAddressAddressUtxoGetError> = serde_json::from_str(&local_var_content).ok();
505 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
506 Err(Error::ResponseError(local_var_error))
507 }
508}
509
510pub async fn contract_nft_sell_genesis_code_hash_genesis_utxo_get(configuration: &configuration::Configuration, code_hash: &str, genesis: &str, token_index: Option<i64>, max: Option<i64>, min: Option<i64>) -> Result<Vec<crate::models::ContractNftSellUtxo>, Error<ContractNftSellGenesisCodeHashGenesisUtxoGetError>> {
511 let local_var_configuration = configuration;
512
513 let local_var_client = &local_var_configuration.client;
514
515 let local_var_uri_str = format!("{}/contract/nft/sell/genesis/{codeHash}/{genesis}/utxo", local_var_configuration.base_path, codeHash=crate::apis::urlencode(code_hash), genesis=crate::apis::urlencode(genesis));
516 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
517
518 if let Some(ref local_var_str) = token_index {
519 local_var_req_builder = local_var_req_builder.query(&[("tokenIndex", &local_var_str.to_string())]);
520 }
521 if let Some(ref local_var_str) = max {
522 local_var_req_builder = local_var_req_builder.query(&[("max", &local_var_str.to_string())]);
523 }
524 if let Some(ref local_var_str) = min {
525 local_var_req_builder = local_var_req_builder.query(&[("min", &local_var_str.to_string())]);
526 }
527 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
528 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
529 }
530 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
531 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
532 };
533
534 let local_var_req = local_var_req_builder.build()?;
535 let local_var_resp = local_var_client.execute(local_var_req).await?;
536
537 let local_var_status = local_var_resp.status();
538 let local_var_content = local_var_resp.text().await?;
539
540 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
541 serde_json::from_str(&local_var_content).map_err(Error::from)
542 } else {
543 let local_var_entity: Option<ContractNftSellGenesisCodeHashGenesisUtxoGetError> = serde_json::from_str(&local_var_content).ok();
544 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
545 Err(Error::ResponseError(local_var_error))
546 }
547}
548
549pub async fn contract_unique_genesis_code_hash_genesis_utxo_get(configuration: &configuration::Configuration, code_hash: &str, genesis: &str) -> Result<Vec<crate::models::ContractUniqueUtxo>, Error<ContractUniqueGenesisCodeHashGenesisUtxoGetError>> {
550 let local_var_configuration = configuration;
551
552 let local_var_client = &local_var_configuration.client;
553
554 let local_var_uri_str = format!("{}/contract/unique/genesis/{codeHash}/{genesis}/utxo", local_var_configuration.base_path, codeHash=crate::apis::urlencode(code_hash), genesis=crate::apis::urlencode(genesis));
555 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
556
557 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
558 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
559 }
560 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
561 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
562 };
563
564 let local_var_req = local_var_req_builder.build()?;
565 let local_var_resp = local_var_client.execute(local_var_req).await?;
566
567 let local_var_status = local_var_resp.status();
568 let local_var_content = local_var_resp.text().await?;
569
570 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
571 serde_json::from_str(&local_var_content).map_err(Error::from)
572 } else {
573 let local_var_entity: Option<ContractUniqueGenesisCodeHashGenesisUtxoGetError> = serde_json::from_str(&local_var_content).ok();
574 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
575 Err(Error::ResponseError(local_var_error))
576 }
577}
578