mirrorworld_sdk_rust/
authentication.rs

1use reqwest::header::HeaderMap;
2use serde::Deserialize;
3use serde::Serialize;
4use std::collections::HashMap;
5use std::error::Error;
6use std::option::Option;
7
8#[derive(Debug, Serialize, Deserialize)]
9pub struct Response<T> {
10    pub status: Option<String>,
11    pub data: Option<T>,
12    pub code: Option<u32>,
13    pub message: Option<String>,
14}
15
16// Completes user signup with email
17
18pub struct LoginWithEmailParam<'a> {
19    pub email: &'a str,
20    pub code: &'a str,
21    pub password: &'a str,
22}
23
24#[derive(Debug, Serialize, Deserialize)]
25pub struct LoginWithEmailRes {
26    pub access_token: Option<String>,
27    pub refresh_token: Option<String>,
28    pub user: Option<LoginWithEmailUserAttribute>,
29}
30
31#[derive(Debug, Serialize, Deserialize)]
32pub struct LoginWithEmailUserAttribute {
33    pub allow_spend: bool,
34    pub id: usize,
35    pub eth_address: Option<String>,
36    pub sol_address: Option<String>,
37    pub email: String,
38    pub email_verified: bool,
39    pub is_subaccount: bool,
40    pub username: String,
41    pub main_user_id: Option<String>,
42    pub wallet: LoginWithEmailWalletAttribute,
43    #[serde(rename = "createdAt")]
44    pub created_at: String,
45    #[serde(rename = "updatedAt")]
46    pub updated_at: String,
47}
48
49#[derive(Debug, Serialize, Deserialize)]
50pub struct LoginWithEmailWalletAttribute {
51    pub eth_address: String,
52    pub sol_address: String,
53}
54
55#[tokio::main]
56pub async fn complete_signup(
57    payload: LoginWithEmailParam,
58) -> Result<Option<Response<LoginWithEmailRes>>, Box<dyn Error>> {
59    let mut headers = HeaderMap::new();
60    headers.insert("Content-Type", "application/json".parse().unwrap());
61    headers.insert("Accept", "application/json".parse().unwrap());
62    headers.insert("x-api-key", crate::get_apikey().parse().unwrap());
63    let mut map = HashMap::new();
64    map.insert("code", payload.code.to_string());
65    map.insert("email", payload.email.to_string());
66    map.insert("password", payload.password.to_string());
67    let url: String =
68        crate::STAGING_REQUEST_URL.to_string() + &"/v1/auth/complete-signup".to_string();
69    let client = reqwest::Client::new();
70    let res = client
71        .post(url)
72        .headers(headers)
73        .json(&map)
74        .send()
75        .await
76        .unwrap();
77    let p = res.json::<Response<LoginWithEmailRes>>().await?;
78    println!("login_with_email_code_response_is_{:?}", p);
79    Ok(Some(p))
80}
81
82// Registers a user with email.
83
84#[tokio::main]
85pub async fn signup_email(
86    email: &str,
87) -> Result<Option<Response<LoginWithEmailRes>>, Box<dyn Error>> {
88    let mut headers = HeaderMap::new();
89    headers.insert("Content-Type", "application/json".parse().unwrap());
90    headers.insert("Accept", "application/json".parse().unwrap());
91    headers.insert("x-api-key", crate::get_apikey().parse().unwrap());
92    let mut map = HashMap::new();
93    map.insert("email", email.to_string());
94    let url: String = crate::STAGING_REQUEST_URL.to_string() + &"/v1/auth/signup".to_string();
95    let client = reqwest::Client::new();
96    let res = client
97        .post(url)
98        .headers(headers)
99        .json(&map)
100        .send()
101        .await
102        .unwrap();
103    let p = res.json::<Response<LoginWithEmailRes>>().await?;
104    println!("login_with_email_code_response_is_{:?}", p);
105    Ok(Some(p))
106}
107
108// Logs in a user with email and password
109
110pub struct LoginParam<'a> {
111    pub email: &'a str,
112    pub password: &'a str,
113}
114
115#[tokio::main]
116pub async fn login(
117    payload: LoginParam,
118) -> Result<Option<Response<LoginWithEmailRes>>, Box<dyn Error>> {
119    let mut headers = HeaderMap::new();
120    headers.insert("Content-Type", "application/json".parse().unwrap());
121    headers.insert("Accept", "application/json".parse().unwrap());
122    headers.insert("x-api-key", crate::get_apikey().parse().unwrap());
123    let mut map = HashMap::new();
124    map.insert("email", payload.email.to_string());
125    map.insert("password", payload.password.to_string());
126    let url: String = crate::STAGING_REQUEST_URL.to_string() + &"/v1/auth/login".to_string();
127    let client = reqwest::Client::new();
128    let res = client
129        .post(url)
130        .headers(headers)
131        .json(&map)
132        .send()
133        .await
134        .unwrap();
135    let p = res.json::<Response<LoginWithEmailRes>>().await?;
136    Ok(Some(p))
137}
138
139//Logs in a user with Google OAuth
140#[tokio::main]
141pub async fn login_google(
142    identity_provider_token: String,
143) -> Result<Option<Response<LoginWithEmailRes>>, Box<dyn Error>> {
144    let mut headers = HeaderMap::new();
145    headers.insert("Content-Type", "application/json".parse().unwrap());
146    headers.insert("Accept", "application/json".parse().unwrap());
147    headers.insert("x-api-key", crate::get_apikey().parse().unwrap());
148    let mut map = HashMap::new();
149    map.insert(
150        "identity_provider_token",
151        identity_provider_token.to_string(),
152    );
153    let url: String = crate::STAGING_REQUEST_URL.to_string() + &"/v1/auth/google".to_string();
154    let client = reqwest::Client::new();
155    let res = client
156        .post(url)
157        .headers(headers)
158        .json(&map)
159        .send()
160        .await
161        .unwrap();
162    let p = res.json::<Response<LoginWithEmailRes>>().await?;
163    Ok(Some(p))
164}
165
166// GETChecks whether is authenticated or not and returns the user object if true
167
168#[derive(Debug, Serialize, Deserialize)]
169pub struct FetchUser {
170    pub id: u32,
171    pub eth_address: Option<String>,
172    pub sol_address: Option<String>,
173    pub email: Option<String>,
174    pub email_verified: bool,
175    pub username: String,
176    #[serde(rename = "createdAt")]
177    pub created_at: String,
178    #[serde(rename = "updatedAt")]
179    pub updated_at: String,
180    pub wallet: LoginWithEmailWalletAttribute,
181}
182#[tokio::main]
183pub async fn fetch_user() -> Result<Option<Response<FetchUser>>, Box<dyn Error>> {
184    let mut headers = HeaderMap::new();
185    headers.insert("Accept", "application/json".parse().unwrap());
186    headers.insert("x-api-key", crate::get_apikey().parse().unwrap());
187    headers.insert("authorization", crate::get_auth().parse().unwrap());
188    let url: String = crate::STAGING_REQUEST_URL.to_string() + &"/v1/auth/me".to_string();
189    let client = reqwest::Client::new();
190    let res = client.get(url).headers(headers).send().await.unwrap();
191    let p = res.json::<Response<FetchUser>>().await?;
192    Ok(Some(p))
193}
194
195#[derive(Debug, Serialize, Deserialize)]
196pub struct WalletTokens {
197    pub sol: u32,
198    pub tokens: Option<Vec<WalletToken>>,
199}
200#[derive(Debug, Serialize, Deserialize)]
201pub struct WalletToken {
202    pub ata: Option<String>,
203    pub mint: Option<String>,
204    pub amount: Option<u32>,
205    pub decimals: Option<u32>,
206}
207#[tokio::main]
208pub async fn get_tokens() -> Result<Option<Response<WalletToken>>, Box<dyn Error>> {
209    let mut headers = HeaderMap::new();
210    headers.insert("Accept", "application/json".parse().unwrap());
211    headers.insert("x-api-key", crate::get_apikey().parse().unwrap());
212    headers.insert("authorization", crate::get_auth().parse().unwrap());
213    let url: String = crate::STAGING_REQUEST_URL.to_string() + &"/v1/wallet/tokens".to_string();
214    let client = reqwest::Client::new();
215    let res = client.get(url).headers(headers).send().await.unwrap();
216    let p = res.json::<Response<WalletToken>>().await?;
217    println!("{:?}", p.status);
218    Ok(Some(p))
219}
220
221//Fetches the wallet transactions for a user
222
223#[derive(Debug, Serialize, Deserialize)]
224pub struct Transactions {
225    pub count: u32,
226    pub next_before: Option<String>,
227    pub tokens: Option<Vec<Transaction>>,
228}
229#[derive(Debug, Serialize, Deserialize)]
230pub struct Transaction {
231    #[serde(rename = "blockTime")]
232    pub block_time: Option<String>,
233    pub slot: Option<u32>,
234    pub meta: Option<Meta>,
235    pub transaction: Option<TransactionItem>,
236}
237
238#[derive(Debug, Serialize, Deserialize)]
239pub struct TransactionItem {
240    pub message: Message,
241    pub signatures: Option<String>,
242}
243
244#[derive(Debug, Serialize, Deserialize)]
245pub struct Message {
246    #[serde(rename = "accountKeys")]
247    pub account_keys: Option<Vec<AccountKeysEntity>>,
248    #[serde(rename = "addressTableLookups")]
249    pub address_table_lookups: Option<String>,
250    pub instructions: Option<Vec<ParsedInstructionEntity>>,
251    #[serde(rename = "recentBlockhash")]
252    pub recent_blockhash: String,
253}
254
255#[derive(Debug, Serialize, Deserialize)]
256pub struct AccountKeysEntity {
257    pub pubkey: Option<String>,
258    pub signer: Option<bool>,
259    pub writable: Option<bool>,
260}
261
262#[derive(Debug, Serialize, Deserialize)]
263pub struct ParsedInstructionEntity {
264    pub accounts: Option<String>,
265    pub data: Option<String>,
266    #[serde(rename = "programId")]
267    pub program_id: Option<String>,
268    pub parsed: Option<ParsedInstruction>,
269    pub program: Option<String>,
270}
271
272#[derive(Debug, Serialize, Deserialize)]
273pub struct ParsedInstruction {
274    pub info: Info,
275    pub r#type: Option<String>,
276}
277
278#[derive(Debug, Serialize, Deserialize)]
279pub struct Info {
280    pub account: Option<String>,
281    pub mint: Option<String>,
282    #[serde(rename = "rentSysvar")]
283    pub rent_sysvar: Option<String>,
284    pub source: Option<String>,
285    #[serde(rename = "systemProgram")]
286    pub system_program: Option<String>,
287    #[serde(rename = "tokenProgram")]
288    pub token_program: Option<String>,
289    pub wallet: Option<String>,
290    pub amount: Option<String>,
291    pub authority: Option<String>,
292    pub destination: Option<String>,
293    pub lamports: Option<u32>,
294    #[serde(rename = "tokenAmount")]
295    pub token_amount: Option<TokenAmount>,
296}
297
298#[derive(Debug, Serialize, Deserialize)]
299pub struct TokenAmount {
300    pub amount: Option<String>,
301    pub decimals: Option<u32>,
302    #[serde(rename = "uiAmount")]
303    pub ui_amount: Option<u32>,
304    #[serde(rename = "uiAmountString")]
305    pub ui_amount_string: Option<String>,
306}
307
308#[derive(Debug, Serialize, Deserialize)]
309pub struct Meta {
310    pub err: Option<Err>,
311    pub fee: u32,
312    #[serde(rename = "innerInstructions")]
313    pub inner_instructions: Option<InnerInstructionsEntity>,
314    #[serde(rename = "loadedAddresses")]
315    pub loaded_addresses: Option<LoadedAddresses>,
316    #[serde(rename = "logMessages")]
317    pub log_messages: Option<String>,
318    #[serde(rename = "postBalances")]
319    pub post_balances: Option<u32>,
320    #[serde(rename = "postTokenBalances")]
321    pub post_token_balances: Option<PostTokenBalancesEntity>,
322    #[serde(rename = "preBalances")]
323    pub pre_balances: Option<u32>,
324    #[serde(rename = "preTokenBalances")]
325    pub pre_token_balances: Option<PreTokenBalancesEntityOrPostTokenBalancesEntity>,
326    pub status: Option<Status>,
327}
328
329#[derive(Debug, Serialize, Deserialize)]
330pub struct Status {
331    #[serde(rename = "Ok")]
332    pub ok: Option<String>,
333    #[serde(rename = "Err")]
334    pub err: Option<InstructionError>,
335}
336
337#[derive(Debug, Serialize, Deserialize)]
338pub struct InstructionError {
339    #[serde(rename = "InstructionError")]
340    pub instruction_error: Option<String>,
341}
342
343#[derive(Debug, Serialize, Deserialize)]
344pub struct PreTokenBalancesEntityOrPostTokenBalancesEntity {
345    #[serde(rename = "accountIndex")]
346    pub account_index: u32,
347    pub mint: Option<String>,
348    pub owner: Option<String>,
349    #[serde(rename = "programId")]
350    pub program_id: Option<String>,
351    #[serde(rename = "uiTokenAmount")]
352    pub ui_token_amount: UiTokenAmountOrTokenAmount,
353}
354
355#[derive(Debug, Serialize, Deserialize)]
356pub struct UiTokenAmountOrTokenAmount {
357    pub amount: Option<String>,
358    pub decimals: Option<u32>,
359    #[serde(rename = "uiAmount")]
360    pub ui_amount: Option<u32>,
361    #[serde(rename = "uiAmountString")]
362    pub ui_amount_string: Option<String>,
363}
364#[derive(Debug, Serialize, Deserialize)]
365pub struct LoadedAddresses {
366    pub readonly: Option<Vec<String>>,
367    pub writable: Option<Vec<String>>,
368}
369
370#[derive(Debug, Serialize, Deserialize)]
371pub struct PostTokenBalancesEntity {
372    #[serde(rename = "accountIndex")]
373    pub account_index: Option<u32>,
374    pub mint: Option<String>,
375    pub owner: Option<String>,
376    #[serde(rename = "programId")]
377    pub program_id: Option<String>,
378    #[serde(rename = "uiTokenAmount")]
379    pub ui_token_amount: UiTokenAmount,
380}
381
382#[derive(Debug, Serialize, Deserialize)]
383pub struct UiTokenAmount {
384    pub amount: String,
385    pub decimals: u32,
386    #[serde(rename = "uiAmount")]
387    pub ui_amount: Option<u32>,
388    #[serde(rename = "uiAmountString")]
389    pub ui_amount_string: String,
390}
391
392#[derive(Debug, Serialize, Deserialize)]
393pub struct InnerInstructionsEntity {
394    pub index: u32,
395    pub instructions: Option<Vec<InstructionsEntity>>,
396}
397
398#[derive(Debug, Serialize, Deserialize)]
399pub struct InstructionsEntity {
400    pub parsed: Option<Parsed>,
401    pub program: Option<String>,
402    #[serde(rename = "programId")]
403    pub program_id: Option<String>,
404    pub accounts: Option<Vec<String>>,
405    pub data: Option<String>,
406}
407
408#[derive(Debug, Serialize, Deserialize)]
409pub struct Parsed {
410    pub info: ParsedInfo,
411    pub r#type: String,
412}
413
414#[derive(Debug, Serialize, Deserialize)]
415pub struct ParsedInfo {
416    pub destination: Option<String>,
417    pub lamports: Option<u32>,
418    pub source: Option<String>,
419    pub account: Option<String>,
420    pub mint: Option<String>,
421    #[serde(rename = "rentSysvar")]
422    pub rent_sysvar: Option<String>,
423    #[serde(rename = "systemProgram")]
424    pub system_program: Option<String>,
425    #[serde(rename = "tokenProgram")]
426    pub token_program: Option<String>,
427    pub wallet: Option<String>,
428    #[serde(rename = "newAccount")]
429    pub new_account: Option<String>,
430    pub owner: Option<String>,
431    pub space: Option<u32>,
432    pub amount: Option<String>,
433    #[serde(rename = "mintAuthority")]
434    pub mint_authority: Option<String>,
435    #[serde(rename = "authorityType")]
436    pub authority_type: Option<String>,
437    #[serde(rename = "multisigAuthority")]
438    pub multisig_authority: Option<String>,
439    #[serde(rename = "newAuthority")]
440    pub new_authority: Option<String>,
441    pub signers: Option<Vec<String>>,
442    pub decimals: Option<u32>,
443    pub authority: Option<String>,
444    pub delegate: Option<String>,
445}
446
447#[derive(Debug, Serialize, Deserialize)]
448pub struct Err {
449    #[serde(rename = "InstructionError")]
450    pub instruction_error: Option<String>,
451}
452#[tokio::main]
453pub async fn get_transactions() -> Result<Option<Response<Transactions>>, Box<dyn Error>> {
454    let mut headers = HeaderMap::new();
455    headers.insert("Accept", "application/json".parse().unwrap());
456    headers.insert("x-api-key", crate::get_apikey().parse().unwrap());
457    headers.insert("authorization", crate::get_auth().parse().unwrap());
458    let url: String =
459        crate::STAGING_REQUEST_URL.to_string() + &"/v1/wallet/transactions".to_string();
460    let client = reqwest::Client::new();
461    let res = client.get(url).headers(headers).send().await.unwrap();
462    let p = res.json::<Response<Transactions>>().await?;
463    println!("{:?}", p.status);
464    Ok(Some(p))
465}
466
467// GET Fetch single NFT details
468#[derive(Debug, Serialize, Deserialize)]
469pub struct ISolanaNFT {
470    pub name: Option<String>,
471    #[serde(rename = "sellerFeeBasisPoints")]
472    pub seller_fee_basis_points: Option<u32>,
473    #[serde(rename = "updateAuthorityAddress")]
474    pub update_authority_address: Option<String>,
475    pub description: Option<String>,
476    pub image: Option<String>,
477    #[serde(rename = "externalUrl")]
478    pub external_url: Option<String>,
479    pub creators: Option<Vec<Creator>>,
480    pub owner: Owner,
481    pub attributes: Option<Vec<MetadataAttribute>>,
482    pub listings: Option<Vec<String>>,
483}
484
485#[derive(Debug, Serialize, Deserialize)]
486pub struct Creator {
487    pub address: Option<String>,
488    pub verified: Option<bool>,
489    pub share: Option<u32>,
490}
491
492#[derive(Debug, Serialize, Deserialize)]
493pub struct Owner {
494    pub address: Option<String>,
495}
496
497#[derive(Debug, Serialize, Deserialize)]
498pub struct MetadataAttribute {
499    pub trait_type: Option<String>,
500    pub value: Option<String>,
501}
502
503#[derive(Debug, Serialize, Deserialize)]
504pub struct CreateVerifiedCollectionPayload {
505    pub name: Option<String>,
506    pub symbol: Option<String>,
507    #[serde(rename = "metadataUri")]
508    pub metadata_uri: Option<String>,
509}
510
511#[derive(Debug, Serialize, Deserialize)]
512pub struct ICreateVerifiedCollectionPayload {
513    pub name: Option<String>,
514    pub symbol: Option<String>,
515    #[serde(rename = "metadataUri")]
516    pub metadata_uri: Option<String>,
517    pub url: Option<String>,
518}
519
520#[derive(Debug, Serialize, Deserialize)]
521pub struct CreateVerifiedSubCollectionPayload {
522    pub name: Option<String>,
523    pub symbol: Option<String>,
524    #[serde(rename = "metadataUri")]
525    pub metadata_uri: Option<String>,
526    #[serde(rename = "parentCollection")]
527    pub parent_collection: Option<String>,
528}
529
530#[derive(Debug, Serialize, Deserialize)]
531pub struct ICreateVerifiedSubCollectionPayload {
532    pub name: Option<String>,
533    pub symbol: Option<String>,
534    #[serde(rename = "metadataUri")]
535    pub metadata_uri: Option<String>,
536    pub url: Option<String>,
537    pub collection_mint: Option<String>,
538}
539
540#[derive(Debug, Serialize, Deserialize)]
541pub struct IMintNFTPayload {
542    pub collection_mint: Option<String>,
543    pub name: Option<String>,
544    pub symbol: Option<String>,
545    pub url: Option<String>,
546}
547
548#[derive(Debug, Serialize, Deserialize)]
549pub struct MintNFTPayload {
550    #[serde(rename = "metadataUri")]
551    pub metadata_uri: Option<String>,
552    pub collection: Option<String>,
553    pub collection_mint: Option<String>,
554    pub name: Option<String>,
555    pub symbol: Option<String>,
556    pub url: Option<String>,
557}
558
559#[derive(Debug, Serialize, Deserialize)]
560pub struct IListNFTPayload {
561    pub mint_address: Option<String>,
562    pub price: Option<u32>,
563}
564
565#[derive(Debug, Serialize, Deserialize)]
566pub struct ListNFTPayload {
567    pub mint_address: Option<String>,
568    pub price: Option<u32>,
569}
570
571#[derive(Debug, Serialize, Deserialize)]
572pub struct IUpdateListingPayload {
573    pub mint_address: Option<String>,
574    pub price: Option<u32>,
575}
576
577#[derive(Debug, Serialize, Deserialize)]
578pub struct UpdateListingPayload {
579    pub mint_address: Option<String>,
580    pub price: Option<u32>,
581}
582
583#[derive(Debug, Serialize, Deserialize)]
584pub struct IBuyNFTPayload {
585    pub mint_address: String,
586    pub price: Option<u32>,
587}
588
589#[derive(Debug, Serialize, Deserialize)]
590pub struct BuyNFTPayload {
591    pub mint_address: String,
592    pub price: Option<u32>,
593}
594
595#[derive(Debug, Serialize, Deserialize)]
596pub struct ICancelNFTPayload {
597    pub mint_address: String,
598    pub price: Option<u32>,
599}
600
601#[derive(Debug, Serialize, Deserialize)]
602pub struct CancelListingPayload {
603    pub mint_address: String,
604    pub price: Option<u32>,
605}
606
607#[derive(Debug, Serialize, Deserialize)]
608pub struct ITransferNFTPayload {
609    pub mint_address: String,
610    pub to_wallet_address: Option<u32>,
611}
612
613#[derive(Debug, Serialize, Deserialize)]
614pub struct TransferNFTPayload {
615    #[serde(rename = "mintAddress")]
616    pub mint_address: Option<String>,
617    #[serde(rename = "recipientAddress")]
618    pub recipient_address: String,
619}
620
621#[derive(Debug, Serialize, Deserialize)]
622pub struct IVerifiedCollection {
623    pub mint_address: String,
624    pub url: String,
625    pub update_authority: String,
626    pub creator_address: String,
627    pub name: String,
628    pub symbol: String,
629    pub collection: Option<String>,
630    pub signature: String,
631    pub status: String,
632}
633
634#[derive(Debug, Serialize, Deserialize)]
635pub struct QueryNFTsBase {
636    pub limit: u32,
637    pub offset: u32,
638}
639
640#[derive(Debug, Serialize, Deserialize)]
641pub struct QueryNFTsByMintAddressesPayload {
642    pub limit: Option<u32>,
643    pub offset: Option<u32>,
644    #[serde(rename = "mintAddresses")]
645    pub mint_addresses: Option<Vec<String>>,
646}
647
648#[derive(Debug, Serialize, Deserialize)]
649pub struct QueryNFTsByCreatorsPayload {
650    pub limit: Option<u32>,
651    pub offset: Option<u32>,
652    #[serde(rename = "creatorAddresses")]
653    pub creator_addresses: Option<Vec<String>>,
654}
655
656#[derive(Debug, Serialize, Deserialize)]
657pub struct QueryNFTsByUpdateAuthoritiesPayload {
658    pub limit: Option<u32>,
659    pub offset: Option<u32>,
660    #[serde(rename = "updateAuthorities")]
661    pub update_authorities: Option<Vec<String>>,
662}
663
664#[derive(Debug, Serialize, Deserialize)]
665pub struct QueryNFTsByOwnersPayload {
666    pub limit: Option<u32>,
667    pub offset: Option<u32>,
668    pub owners: Option<Vec<String>>,
669}
670
671#[derive(Debug, Serialize, Deserialize)]
672pub struct SolanaNFTExtended {
673    pub name: Option<String>,
674    #[serde(rename = "sellerFeeBasisPoints")]
675    pub seller_fee_basis_points: Option<u32>,
676    #[serde(rename = "updateAuthorityAddress")]
677    pub update_authority_address: Option<String>,
678    pub description: Option<String>,
679    pub image: Option<String>,
680    #[serde(rename = "externalUrl")]
681    pub external_url: Option<String>,
682    pub creators: Option<Vec<Creator>>,
683    pub owner: Owner,
684    pub attributes: Option<Vec<MetadataAttributes>>,
685    pub listings: Option<Vec<SolanaNFTListing>>,
686}
687
688#[derive(Debug, Serialize, Deserialize)]
689pub struct MetadataAttributes {
690    pub trait_type: Option<String>,
691    pub value: Option<String>,
692}
693
694#[derive(Debug, Serialize, Deserialize)]
695pub struct SolanaNFTListing {
696    pub id: Option<u32>,
697    #[serde(rename = "tradeState")]
698    pub trade_state: Option<String>,
699    pub seller: Option<String>,
700    pub metadata: Option<String>,
701    #[serde(rename = "purchaseId")]
702    pub purchase_id: Option<String>,
703    pub price: Option<u32>,
704    #[serde(rename = "tokenSize")]
705    pub token_size: Option<u32>,
706    #[serde(rename = "createdAt")]
707    pub created_at: Option<String>,
708    #[serde(rename = "canceledAt")]
709    pub canceled_at: Option<String>,
710}
711
712#[derive(Debug, Serialize, Deserialize)]
713pub struct SolanaNFTAuctionActivitiesPayload {
714    #[serde(rename = "mintAddress")]
715    pub mint_address: Option<String>,
716    #[serde(rename = "auctionActivities")]
717    pub auction_activities: Option<Vec<SolanaNFTAuctionActivity>>,
718    #[serde(rename = "tokenTransfers")]
719    pub token_transfers: Option<Vec<SolanaNFTTransfersEntity>>,
720}
721
722#[derive(Debug, Serialize, Deserialize)]
723pub struct SolanaNFTAuctionActivity {
724    pub id: Option<u32>,
725    #[serde(rename = "mintAddress")]
726    pub mint_address: Option<String>,
727    #[serde(rename = "txSignature")]
728    pub tx_signature: Option<String>,
729    pub amount: Option<u32>,
730    #[serde(rename = "receiptType")]
731    pub receipt_type: Option<String>,
732    #[serde(rename = "tokenPrice")]
733    pub token_price: Option<String>,
734    #[serde(rename = "blockTimeCreated")]
735    pub block_time_created: Option<String>,
736    #[serde(rename = "blockTimeCanceled")]
737    pub block_time_canceled: Option<String>,
738    #[serde(rename = "tradeState")]
739    pub trade_state: Option<String>,
740    #[serde(rename = "auctionHouseAddress")]
741    pub auction_house_address: Option<String>,
742    #[serde(rename = "sellerAddress")]
743    pub seller_address: Option<String>,
744    #[serde(rename = "buyerAddress")]
745    pub buyer_address: Option<String>,
746    pub metadata: Option<String>,
747    #[serde(rename = "blockTime")]
748    pub block_time: Option<String>,
749}
750
751#[derive(Debug, Serialize, Deserialize)]
752pub struct SolanaNFTTransfersEntity {
753    pub id: Option<u32>,
754    #[serde(rename = "mintAddress")]
755    pub mint_address: Option<String>,
756    #[serde(rename = "txSignature")]
757    pub tx_signature: Option<String>,
758    #[serde(rename = "fromWalletAddress")]
759    pub from_wallet_address: Option<String>,
760    #[serde(rename = "toWalletAddress")]
761    pub to_wallet_address: Option<String>,
762    pub amount: Option<u32>,
763    #[serde(rename = "blockTime")]
764    pub block_time: Option<String>,
765    pub slot: Option<u32>,
766}
767
768#[derive(Debug, Serialize, Deserialize)]
769pub struct ISolanaNFTMintResult {
770    pub mint_address: Option<String>,
771    pub url: Option<String>,
772    pub update_authority: Option<String>,
773    pub creator_address: Option<String>,
774    pub name: Option<String>,
775    pub symbol: Option<String>,
776    pub collection: Option<String>,
777    pub signature: Option<String>,
778    pub status: Option<String>,
779}
780#[tokio::main]
781pub async fn get_nft_details(
782    sol_addr: &str,
783) -> Result<Option<Response<ISolanaNFT>>, Box<dyn Error>> {
784    let mut headers = HeaderMap::new();
785    headers.insert("Accept", "application/json".parse().unwrap());
786    headers.insert("x-api-key", crate::get_apikey().parse().unwrap());
787    headers.insert("authorization", crate::get_auth().parse().unwrap());
788    let url: String =
789        crate::STAGING_REQUEST_URL.to_string() + &"/v1/solana/nft/".to_string() + sol_addr;
790    let client = reqwest::Client::new();
791    let res = client.get(url).headers(headers).send().await.unwrap();
792    let p = res.json::<Response<ISolanaNFT>>().await?;
793    println!("{:?}", p.status);
794    Ok(Some(p))
795}
mirrorworld_sdk_rust/authentication.rs

mirrorworld_sdk_rust/
authentication.rs
