mirrorworld_sdk_rust/
wallet.rs

1use std::collections::HashMap;
2use reqwest::header::HeaderMap;
3use std::option::Option;
4use serde::Deserialize;
5use serde::Serialize;
6use serde_json::value::Value;
7use serde_json::{json, Map};
8use std::error::Error;
9use crate::{ActionType, get_basic_url, get_env_name, get_request_header, NetEnv};
10use crate::marketplace::approve_token;
11
12#[derive(Debug, Serialize, Deserialize)]
13pub struct Response<T> {
14    pub status: Option<String>,
15    pub data: Option<T>,
16    pub code: Option<u32>,
17    pub message: Option<String>,
18    // pub error: Option<String>,
19}
20
21#[derive(Debug, Serialize, Deserialize)]
22pub struct TransferSpltoken  {
23  pub tx_signature: String
24}
25
26#[derive(Debug, Serialize, Deserialize)]
27pub struct ISolanaToken {
28    pub ata: String,
29    pub mint: String,
30    pub amount: String,
31}
32
33#[derive(Debug, Serialize, Deserialize)]
34pub struct SolanaTokenInfo {
35    pub ata: String,
36    pub mint: String,
37    pub amount: usize,
38    pub decimals: usize,
39}
40
41#[derive(Debug, Serialize, Deserialize)]
42pub struct GetSolanaTokens {
43    pub tokens: Vec<SolanaTokenInfo>,
44    pub sol: usize,
45}
46
47#[derive(Debug, Serialize, Deserialize)]
48pub struct GetTransactions {
49    pub transactions: Vec<TransactionInfo>,
50    pub count: usize,
51}
52
53#[derive(Debug, Serialize, Deserialize)]
54pub struct TransactionInfo {
55
56    #[serde(rename = "blockTime")]
57    pub block_time: usize,
58    pub slot: usize,
59    pub transaction: TransactionDetail,
60}
61
62#[derive(Debug, Serialize, Deserialize)]
63pub struct TransactionDetail {
64    pub signatures: Vec<String>,
65}
66
67pub struct Wallet {
68    api_key: String,
69    net: NetEnv,
70    token: String,
71    secret_key: String,
72}
73
74impl Wallet {
75    pub fn new(api_key: String, env: NetEnv, token:String, secretKey: String) -> Wallet {
76        Wallet{api_key, net: env, token, secret_key: secretKey}
77    }
78
79    pub async fn transfer_spltoken(&self, payload:(&str, &str, &str, &str))-> Result<Option<TransferSpltoken>, Box<dyn Error>>
80    {
81        let mut headers = get_request_header(self.api_key.to_string(), self.token.to_string());
82        let mut approve_headers = get_request_header(self.api_key.to_string(), self.secret_key.to_string());
83
84        let mut data = Map::new();
85        let (to_publickey, amount,token_min, decimals ) = payload;
86        data.insert("to_publickey".to_string(), Value::from(to_publickey));
87        data.insert("amount".to_string(), Value::from(amount));
88        data.insert("token_mint".to_string(), Value::from(token_min));
89        data.insert("decimals".to_string(), Value::from(decimals));
90
91        let action_token = approve_token(
92            ActionType::TRANSFER_SPL_TOKEN,
93            approve_headers.clone(),
94            self.net,
95            data.clone()
96        ).await.unwrap();
97        if action_token.is_none() {
98            println!("auction token is none")
99        }
100        let x_token = action_token.unwrap().authorization_token.to_string();
101        headers.insert("x-authorization-token", x_token.parse().unwrap());
102
103        let url_ = format!("/v1/{}/wallet/transfer-token", get_env_name(self.net));
104        let url:String = get_basic_url(self.net) + &url_;
105
106        let client = reqwest::Client::new();
107        let res = client
108            .post(url)
109            .headers(headers)
110            .json(&data)
111            .send()
112            .await.unwrap();
113        let resp = res.json::<Response<TransferSpltoken>>().await?;
114        Ok(resp.data)
115    }
116
117    pub async fn transfer_sol(&self, payload:(&str, &str))-> Result<Option<TransferSpltoken>, Box<dyn Error>>
118    {
119        let mut headers:HeaderMap = get_request_header(self.api_key.to_string(), self.token.to_string());
120        let mut approve_headers = get_request_header(self.api_key.to_string(), self.secret_key.to_string());
121
122        let mut data = Map::new();
123        let (to_publickey, amount ) = payload;
124        data.insert("to_publickey".to_string(), Value::from(to_publickey));
125        data.insert("amount".to_string(), Value::from(amount));
126
127        let action_token = approve_token(
128            ActionType::TRANSFER_SOL,
129            approve_headers.clone(),
130            self.net,
131            data.clone()
132        ).await.unwrap();
133        if action_token.is_none() {
134            panic!("action is none")
135        }
136
137        let x_token = action_token.unwrap().authorization_token.to_string();
138        headers.insert("x-authorization-token", x_token.parse().unwrap());
139
140        let url_ = format!("/v1/{}/wallet/transfer-sol", get_env_name(self.net));
141        let url:String = get_basic_url(self.net) + &url_;
142        let client = reqwest::Client::new();
143        let res = client
144            .post(url)
145            .headers(headers)
146            .json(&data)
147            .send()
148            .await.unwrap();
149        let resp = res.json::<Response<TransferSpltoken>>().await?;
150        Ok(resp.data)
151    }
152
153    pub async fn get_tokens(&self) -> Result<Option<GetSolanaTokens>, Box<dyn Error>> {
154        let mut headers:HeaderMap = get_request_header(self.api_key.to_string(), self.token.to_string());
155
156        let url_ = format!("/v1/{}/wallet/tokens", get_env_name(self.net));
157        let url:String = get_basic_url(self.net) + &url_;
158
159        let client = reqwest::Client::new();
160        let res = client
161            .get(url)
162            .headers(headers)
163            .send()
164            .await.unwrap();
165
166        let resp = res.json::<Response<GetSolanaTokens>>().await?;
167
168        Ok(resp.data)
169    }
170
171    pub async fn get_transactions(&self) -> Result<Option<GetTransactions>, Box<dyn Error>> {
172        let mut headers:HeaderMap = get_request_header(self.api_key.to_string(), self.token.to_string());
173
174        let url_ = format!("/v1/{}/wallet/transactions", get_env_name(self.net));
175        let url:String = get_basic_url(self.net) + &url_;
176        let client = reqwest::Client::new();
177        let res = client
178            .get(url)
179            .headers(headers)
180            .send()
181            .await.unwrap();
182
183        let resp = res.json::<Response<GetTransactions>>().await?;
184        Ok(resp.data)
185    }
186}